@hyperdrive.bot/cli 1.0.6 → 1.0.8

package/dist/commands/project/init.js

@@ -0,0 +1,576 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+const NORMALIZED_WORKFLOW_STATES = [
+    'pending',
+    'enriching',
+    'implementing',
+    'testing',
+    'in_review',
+    'ready_to_merge',
+    'deploying',
+    'validating',
+    'done',
+    'blocked',
+];
+export default class ProjectInit extends Command {
+    static description = 'Initialize a project with Jira integration, repos, and status mapping';
+    static examples = [
+        '<%= config.bin %> project init',
+        '<%= config.bin %> project init --project my-project --jira-key PROJ',
+        '<%= config.bin %> project init --json --name "My Project" --jira-key PROJ',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        'jira-key': Flags.string({
+            description: 'Jira project key (e.g., PROJ)',
+        }),
+        json: Flags.boolean({
+            description: 'Output result as JSON (non-interactive mode)',
+        }),
+        name: Flags.string({
+            description: 'Name for a new project (used with --json)',
+        }),
+        project: Flags.string({
+            description: 'Existing project slug to configure',
+        }),
+        repo: Flags.string({
+            description: 'Repo in format "name|gitRemote|provider|branch" (repeatable, used with --json)',
+            multiple: true,
+        }),
+        'status-map': Flags.string({
+            description: 'Status mapping in format "JiraStatus=normalizedState" (repeatable, used with --json)',
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProjectInit);
+        // JSON mode: validate required flags upfront
+        if (flags.json) {
+            if (!flags.project && !flags.name) {
+                this.error('Non-interactive mode requires --project (existing) or --name (new project).\n\n' +
+                    `Usage: ${chalk.cyan('hd project init --json --name "My Project" --jira-key PROJ')}\n` +
+                    `   or: ${chalk.cyan('hd project init --json --project my-project --jira-key PROJ')}`);
+            }
+            if (!flags['jira-key']) {
+                this.error('Non-interactive mode requires --jira-key.\n\n' +
+                    `Usage: ${chalk.cyan('hd project init --json --name "My Project" --jira-key PROJ')}`);
+            }
+        }
+        // Step: Auth check
+        let service;
+        const spinner = ora('Checking authentication...').start();
+        try {
+            service = new HyperdriveSigV4Service(flags.domain);
+            spinner.succeed('Authenticated');
+        }
+        catch (error) {
+            spinner.fail('Not authenticated');
+            this.error(`${error.message}\n\nPlease authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        // Step (a): Project selection or creation
+        const project = await this.selectOrCreateProject(service, flags);
+        // Step (b): Jira project key
+        const jiraKey = await this.getJiraProjectKey(service, flags);
+        // Step (c): Repo addition
+        const repos = await this.addRepos(service, project, flags);
+        // Step (d): Status mapping
+        const statusMapping = await this.configureStatusMapping(service, project, jiraKey, flags);
+        // Step (e): Confirmation and save
+        const result = {
+            jiraProjectKey: jiraKey,
+            project: { name: project.name, projectId: project.projectId, slug: project.slug },
+            repos: repos.map(r => ({ defaultBranch: r.defaultBranch, gitProvider: r.gitProvider, gitRemote: r.gitRemote, name: r.name })),
+            statusMapping,
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        await this.confirmAndFinalize(result);
+    }
+    async addRepos(service, project, flags) {
+        const repos = [];
+        if (flags.json) {
+            if (!flags.repo || flags.repo.length === 0)
+                return repos;
+            for (const repoStr of flags.repo) {
+                const parts = repoStr.split('|');
+                if (parts.length < 2) {
+                    this.error(`Invalid --repo format: "${repoStr}". Expected "name|gitRemote|provider|branch" (provider defaults to github, branch defaults to main)`);
+                }
+                const [name, gitRemote, gitProvider = 'github', defaultBranch = 'main'] = parts;
+                const repoSpinner = ora(`Adding repository ${name}...`).start();
+                try {
+                    const result = await service.projectAddRepo(project.projectId, {
+                        defaultBranch: defaultBranch.trim(),
+                        gitProvider: gitProvider.trim(),
+                        gitRemote: gitRemote.trim(),
+                        name: name.trim(),
+                    });
+                    repoSpinner.succeed(`Repository ${chalk.cyan(name)} added`);
+                    repos.push(result);
+                }
+                catch (error) {
+                    repoSpinner.fail(`Failed to add repository ${name}`);
+                    const errorMsg = error.response?.data?.message || error.response?.data?.error || error.message;
+                    this.error(errorMsg);
+                }
+            }
+            return repos;
+        }
+        this.log('');
+        this.log(chalk.blue('Step 3: Add Repositories'));
+        this.log(chalk.dim('Link git repositories to this project'));
+        this.log('');
+        const { addRepo } = await inquirer.prompt([{
+                default: true,
+                message: 'Would you like to add a repository?',
+                name: 'addRepo',
+                type: 'confirm',
+            }]);
+        if (!addRepo)
+            return repos;
+        let addMore = true;
+        while (addMore) {
+            const { gitRemote } = await inquirer.prompt([{
+                    message: 'Git remote URL:',
+                    name: 'gitRemote',
+                    type: 'input',
+                    validate: (input) => {
+                        if (!input.trim())
+                            return 'Git remote URL is required';
+                        if (!/^https?:\/\/(github\.com|gitlab\.com)\/.+\/.+/.test(input.trim()) &&
+                            !/^git@(github\.com|gitlab\.com):.+\/.+/.test(input.trim())) {
+                            return 'URL must be a valid GitHub or GitLab repository URL (e.g., https://github.com/org/repo)';
+                        }
+                        return true;
+                    },
+                }]);
+            const derivedName = this.deriveRepoName(gitRemote);
+            const { repoName } = await inquirer.prompt([{
+                    default: derivedName,
+                    message: 'Repo name:',
+                    name: 'repoName',
+                    type: 'input',
+                    validate: (input) => input.trim() ? true : 'Repo name is required',
+                }]);
+            const { gitProvider } = await inquirer.prompt([{
+                    choices: [
+                        { name: 'GitHub', value: 'github' },
+                        { name: 'GitLab', value: 'gitlab' },
+                    ],
+                    default: gitRemote.includes('github.com') ? 'github' : 'gitlab',
+                    message: 'Git provider:',
+                    name: 'gitProvider',
+                    type: 'list',
+                }]);
+            const { defaultBranch } = await inquirer.prompt([{
+                    default: 'main',
+                    message: 'Default branch:',
+                    name: 'defaultBranch',
+                    type: 'input',
+                }]);
+            const repoSpinner = ora('Adding repository...').start();
+            try {
+                const result = await service.projectAddRepo(project.projectId, {
+                    defaultBranch,
+                    gitProvider,
+                    gitRemote: gitRemote.trim(),
+                    name: repoName.trim(),
+                });
+                repoSpinner.succeed(`Repository ${chalk.cyan(repoName)} added`);
+                repos.push(result);
+            }
+            catch (error) {
+                repoSpinner.fail('Failed to add repository');
+                const errorMsg = error.response?.data?.message || error.response?.data?.error || error.message;
+                this.log(chalk.red(`  Error: ${errorMsg}`));
+                const { action } = await inquirer.prompt([{
+                        choices: [
+                            { name: 'Re-enter repo details', value: 'retry' },
+                            { name: 'Skip this repo', value: 'skip' },
+                        ],
+                        message: 'What would you like to do?',
+                        name: 'action',
+                        type: 'list',
+                    }]);
+                if (action === 'retry')
+                    continue;
+            }
+            const { addAnother } = await inquirer.prompt([{
+                    default: false,
+                    message: 'Add another repository?',
+                    name: 'addAnother',
+                    type: 'confirm',
+                }]);
+            addMore = addAnother;
+        }
+        return repos;
+    }
+    async configureStatusMapping(service, project, jiraKey, flags) {
+        const statusMapping = {};
+        if (flags.json) {
+            // Parse --status-map flags if provided
+            if (flags['status-map']) {
+                for (const mapStr of flags['status-map']) {
+                    const eqIdx = mapStr.indexOf('=');
+                    if (eqIdx === -1) {
+                        this.error(`Invalid --status-map format: "${mapStr}". Expected "JiraStatus=normalizedState"`);
+                    }
+                    const jiraStatus = mapStr.slice(0, eqIdx).trim();
+                    const normalizedState = mapStr.slice(eqIdx + 1).trim();
+                    if (!NORMALIZED_WORKFLOW_STATES.includes(normalizedState)) {
+                        this.error(`Invalid normalized state "${normalizedState}". Valid states: ${NORMALIZED_WORKFLOW_STATES.join(', ')}`);
+                    }
+                    statusMapping[jiraStatus] = normalizedState;
+                }
+            }
+            const saveSpinner = ora('Saving Jira configuration...').start();
+            try {
+                await service.projectSetJiraConfig(project.projectId, {
+                    jiraProjectKey: jiraKey,
+                    statusMapping,
+                });
+                saveSpinner.succeed('Jira configuration saved');
+            }
+            catch (error) {
+                saveSpinner.fail('Failed to save Jira configuration');
+                const errorMsg = error.response?.data?.message || error.response?.data?.error || error.message;
+                this.error(errorMsg);
+            }
+            return statusMapping;
+        }
+        this.log('');
+        this.log(chalk.blue('Step 4: Status Mapping'));
+        this.log(chalk.dim('Map Jira statuses to normalized workflow states'));
+        this.log('');
+        // Fetch Jira statuses
+        const statusSpinner = ora('Fetching Jira statuses...').start();
+        let jiraStatuses = [];
+        try {
+            const response = await service.jiraGetProjectStatuses(jiraKey);
+            jiraStatuses = response.statuses;
+            statusSpinner.succeed(`Found ${jiraStatuses.length} Jira statuses`);
+        }
+        catch (error) {
+            statusSpinner.warn('Could not fetch Jira statuses');
+            this.log(chalk.yellow('  Jira may not be connected or the project key may be invalid'));
+            if (error.message) {
+                this.log(chalk.dim(`  Detail: ${error.message}`));
+            }
+            const { action } = await inquirer.prompt([{
+                    choices: [
+                        { name: 'Enter status names manually', value: 'manual' },
+                        { name: 'Skip status mapping', value: 'skip' },
+                    ],
+                    message: 'How would you like to proceed?',
+                    name: 'action',
+                    type: 'list',
+                }]);
+            if (action === 'skip') {
+                // Save config without status mapping
+                const saveSpinner = ora('Saving Jira configuration...').start();
+                try {
+                    await service.projectSetJiraConfig(project.projectId, {
+                        jiraProjectKey: jiraKey,
+                        statusMapping,
+                    });
+                    saveSpinner.succeed('Jira configuration saved (no status mapping)');
+                }
+                catch (error) {
+                    saveSpinner.fail('Failed to save Jira configuration');
+                    const errorMsg = error.response?.data?.message || error.response?.data?.error || error.message;
+                    this.log(chalk.red(`  Error: ${errorMsg}`));
+                }
+                return statusMapping;
+            }
+            // Manual entry
+            const { manualStatuses } = await inquirer.prompt([{
+                    message: 'Enter Jira status names (comma-separated):',
+                    name: 'manualStatuses',
+                    type: 'input',
+                    validate: (input) => input.trim() ? true : 'Enter at least one status name',
+                }]);
+            jiraStatuses = manualStatuses.split(',').map((s, i) => ({
+                id: String(i + 1),
+                name: s.trim(),
+            }));
+        }
+        // Map each Jira status to a normalized state
+        const stateChoices = [
+            ...NORMALIZED_WORKFLOW_STATES.map(s => ({ name: s, value: s })),
+            { name: "Skip (don't map)", value: '__skip__' },
+        ];
+        for (const jiraStatus of jiraStatuses) {
+            const { mapped } = await inquirer.prompt([{
+                    choices: stateChoices,
+                    message: `Map "${chalk.cyan(jiraStatus.name)}" to:`,
+                    name: 'mapped',
+                    type: 'list',
+                }]);
+            if (mapped !== '__skip__') {
+                statusMapping[jiraStatus.name] = mapped;
+            }
+        }
+        // Save Jira config
+        const saveSpinner = ora('Saving Jira configuration...').start();
+        try {
+            await service.projectSetJiraConfig(project.projectId, {
+                jiraProjectKey: jiraKey,
+                statusMapping,
+            });
+            saveSpinner.succeed('Jira configuration saved');
+        }
+        catch (error) {
+            saveSpinner.fail('Failed to save Jira configuration');
+            const errorMsg = error.response?.data?.message || error.response?.data?.error || error.message;
+            this.log(chalk.red(`  Error: ${errorMsg}`));
+        }
+        return statusMapping;
+    }
+    async confirmAndFinalize(result) {
+        this.log('');
+        this.log(chalk.blue('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        this.log(chalk.blue.bold('  Project Configuration Summary'));
+        this.log(chalk.blue('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        this.log('');
+        this.log(`  Project:    ${chalk.cyan(result.project.name)} (${result.project.slug})`);
+        this.log(`  Jira Key:   ${chalk.cyan(result.jiraProjectKey)}`);
+        this.log(`  Repos:      ${chalk.cyan(String(result.repos.length))}`);
+        if (result.repos.length > 0) {
+            for (const repo of result.repos) {
+                this.log(`              - ${repo.name} (${repo.gitRemote})`);
+            }
+        }
+        const mappedCount = Object.keys(result.statusMapping).length;
+        this.log(`  Mapped:     ${chalk.cyan(String(mappedCount))} status${mappedCount !== 1 ? 'es' : ''}`);
+        if (mappedCount > 0) {
+            for (const [jiraStatus, normalizedState] of Object.entries(result.statusMapping)) {
+                this.log(`              ${jiraStatus} -> ${normalizedState}`);
+            }
+        }
+        this.log('');
+        const { confirmed } = await inquirer.prompt([{
+                default: true,
+                message: 'Configuration complete. Continue?',
+                name: 'confirmed',
+                type: 'confirm',
+            }]);
+        if (!confirmed) {
+            this.log(chalk.yellow('Setup cancelled. Your repos and Jira config were already saved during the wizard.'));
+            this.log(chalk.dim('You can modify them using the API or re-run this command.'));
+            return;
+        }
+        this.log('');
+        this.log(chalk.green('Project initialized successfully!'));
+        this.log('');
+        this.log(chalk.dim('Next steps:'));
+        this.log(`  ${chalk.cyan(`hd project status ${result.project.slug}`)}  — View project status`);
+        this.log(`  ${chalk.cyan(`hd project sync ${result.project.slug}`)}    — Sync project with Jira`);
+        this.log('');
+    }
+    deriveRepoName(gitRemote) {
+        try {
+            const url = gitRemote.replace(/\.git$/, '');
+            const parts = url.split('/');
+            return parts[parts.length - 1] || 'repo';
+        }
+        catch {
+            return 'repo';
+        }
+    }
+    async getJiraProjectKey(service, flags) {
+        if (flags.json && flags['jira-key']) {
+            // Validate uniqueness in JSON mode
+            const checkSpinner = ora('Checking Jira key availability...').start();
+            try {
+                await service.projectFindByJiraKey(flags['jira-key']);
+                checkSpinner.fail('Jira key already in use');
+                this.error(`Jira project key "${flags['jira-key']}" is already linked to another project`);
+            }
+            catch (error) {
+                if (error.response?.status === 404) {
+                    checkSpinner.succeed(`Jira key ${chalk.cyan(flags['jira-key'])} is available`);
+                    return flags['jira-key'];
+                }
+                checkSpinner.fail('Failed to check Jira key');
+                throw error;
+            }
+        }
+        if (flags['jira-key'] && !flags.json) {
+            // Flag provided in interactive mode — still validate
+            const checkSpinner = ora('Checking Jira key availability...').start();
+            try {
+                await service.projectFindByJiraKey(flags['jira-key']);
+                checkSpinner.fail('Jira key already in use');
+                this.log(chalk.red(`  Jira project key "${flags['jira-key']}" is already linked to another project`));
+                // Fall through to prompt
+            }
+            catch (error) {
+                if (error.response?.status === 404) {
+                    checkSpinner.succeed(`Jira key ${chalk.cyan(flags['jira-key'])} is available`);
+                    return flags['jira-key'];
+                }
+                checkSpinner.fail('Failed to check Jira key');
+                throw error;
+            }
+        }
+        this.log('');
+        this.log(chalk.blue('Step 2: Jira Project Key'));
+        this.log(chalk.dim('Enter the Jira project key to link'));
+        this.log('');
+        while (true) {
+            const { jiraKey } = await inquirer.prompt([{
+                    message: 'Jira project key:',
+                    name: 'jiraKey',
+                    type: 'input',
+                    validate: (input) => {
+                        if (!input.trim())
+                            return 'Jira project key is required';
+                        if (!/^[A-Z][A-Z0-9_]+$/.test(input.trim())) {
+                            return 'Key must be uppercase alphanumeric (e.g., PROJ, MY_PROJ)';
+                        }
+                        return true;
+                    },
+                }]);
+            const key = jiraKey.trim();
+            const checkSpinner = ora('Checking Jira key availability...').start();
+            try {
+                await service.projectFindByJiraKey(key);
+                checkSpinner.fail(`Jira key ${chalk.cyan(key)} is already in use`);
+                this.log(chalk.yellow('  Please choose a different key'));
+            }
+            catch (error) {
+                if (error.response?.status === 404) {
+                    checkSpinner.succeed(`Jira key ${chalk.cyan(key)} is available`);
+                    return key;
+                }
+                checkSpinner.fail('Failed to check Jira key');
+                this.log(chalk.red(`  Error: ${error.message}`));
+            }
+        }
+    }
+    async selectOrCreateProject(service, flags) {
+        // JSON mode with --name: create new project
+        if (flags.json && flags.name) {
+            const slug = flags.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+            const createSpinner = ora('Creating project...').start();
+            try {
+                const result = await service.moduleCreate({
+                    buildRuntime: 'nodejs',
+                    framework: 'other',
+                    name: flags.name,
+                    runtime: 'nodejs',
+                    slug,
+                    sourceLocation: '',
+                });
+                createSpinner.succeed(`Project ${chalk.cyan(flags.name)} created`);
+                return { name: flags.name, projectId: result.projectId || slug, slug: result.slug || slug };
+            }
+            catch (error) {
+                createSpinner.fail('Failed to create project');
+                this.error(error.response?.data?.message || error.message);
+            }
+        }
+        // JSON mode with --project: look up existing
+        if (flags.json && flags.project) {
+            const lookupSpinner = ora('Looking up project...').start();
+            try {
+                const result = await service.moduleGet({ slug: flags.project });
+                lookupSpinner.succeed(`Project ${chalk.cyan(result.name || flags.project)} found`);
+                return { name: result.name || flags.project, projectId: result.projectId || flags.project, slug: result.slug || flags.project };
+            }
+            catch (error) {
+                lookupSpinner.fail('Project not found');
+                this.error(`Project "${flags.project}" not found. Check the slug and try again.`);
+            }
+        }
+        // Interactive mode with --project flag: skip selection
+        if (flags.project) {
+            const lookupSpinner = ora('Looking up project...').start();
+            try {
+                const result = await service.moduleGet({ slug: flags.project });
+                lookupSpinner.succeed(`Project ${chalk.cyan(result.name || flags.project)} found`);
+                return { name: result.name || flags.project, projectId: result.projectId || flags.project, slug: result.slug || flags.project };
+            }
+            catch (error) {
+                lookupSpinner.fail('Project not found');
+                this.log(chalk.red(`  Project "${flags.project}" not found`));
+                // Fall through to interactive selection
+            }
+        }
+        this.log('');
+        this.log(chalk.blue('Step 1: Select or Create Project'));
+        this.log(chalk.dim('Choose an existing project or create a new one'));
+        this.log('');
+        // Fetch existing projects
+        const listSpinner = ora('Fetching projects...').start();
+        let projects = [];
+        try {
+            projects = await service.moduleList();
+            listSpinner.succeed(`Found ${projects.length} project(s)`);
+        }
+        catch {
+            listSpinner.warn('Could not fetch projects');
+        }
+        const choices = [
+            ...projects.map(p => ({
+                name: `${p.name || p.slug} (${p.slug})`,
+                value: p.slug,
+            })),
+            { name: chalk.green('+ Create new project'), value: '__create_new__' },
+        ];
+        const { selection } = await inquirer.prompt([{
+                choices,
+                message: 'Select a project:',
+                name: 'selection',
+                type: 'list',
+            }]);
+        if (selection === '__create_new__') {
+            const { projectName } = await inquirer.prompt([{
+                    message: 'Project name:',
+                    name: 'projectName',
+                    type: 'input',
+                    validate: (input) => input.trim() ? true : 'Project name is required',
+                }]);
+            const derivedSlug = projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+            const { projectSlug } = await inquirer.prompt([{
+                    default: derivedSlug,
+                    message: 'Project slug:',
+                    name: 'projectSlug',
+                    type: 'input',
+                    validate: (input) => input.trim() ? true : 'Project slug is required',
+                }]);
+            const createSpinner = ora('Creating project...').start();
+            try {
+                const result = await service.moduleCreate({
+                    buildRuntime: 'nodejs',
+                    framework: 'other',
+                    name: projectName.trim(),
+                    runtime: 'nodejs',
+                    slug: projectSlug.trim(),
+                    sourceLocation: '',
+                });
+                createSpinner.succeed(`Project ${chalk.cyan(projectName)} created`);
+                return { name: projectName.trim(), projectId: result.projectId || projectSlug, slug: result.slug || projectSlug };
+            }
+            catch (error) {
+                createSpinner.fail('Failed to create project');
+                this.error(error.response?.data?.message || error.message);
+            }
+        }
+        // Selected existing project
+        const selected = projects.find(p => p.slug === selection);
+        return {
+            name: selected?.name || selection,
+            projectId: selected?.projectId || selection,
+            slug: selected?.slug || selection,
+        };
+    }
+}

package/dist/commands/project/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ProjectList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}