feat: Added support for creating a repo and pushing your project to for github.

Author: dlabaj

README.md

@@ -16,6 +16,14 @@ To install the CLI globally, use npm:
 npm install -g patternfly-cli
 ```
 
+## Prerequisites
+
+Before using the Patternfly CLI, install the following:
+
+- **Node.js and npm** (v20–24) — [npm](https://www.npmjs.com/) · [Node.js downloads](https://nodejs.org/)
+- **Corepack** — enable with `corepack enable` (included with Node.js). Run the command after installing npm.
+- **GitHub CLI** — [Install GitHub CLI](https://cli.github.com/)
+  
 ## Usage
 
 After installation, you can use the CLI by running:

__mocks__/execa.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  execa: jest.fn(),
+};

src/__tests__/cli.test.ts

@@ -2,6 +2,7 @@ import path from 'path';
 import fs from 'fs-extra';
 import { loadCustomTemplates, mergeTemplates } from '../template-loader.js';
 import templates from '../templates.js';
+import { sanitizeRepoName } from '../github.js';
 
 const fixturesDir = path.join(process.cwd(), 'src', '__tests__', 'fixtures');
 
@@ -146,3 +147,20 @@ describe('mergeTemplates', () => {
     }
   });
 });
+
+describe('GitHub support (create command)', () => {
+  it('derives repo name from package name the same way the create command does', () => {
+    // Create command uses sanitizeRepoName(pkgJson.name) for initial repo name
+    expect(sanitizeRepoName('my-app')).toBe('my-app');
+    expect(sanitizeRepoName('@patternfly/my-project')).toBe('my-project');
+    expect(sanitizeRepoName('My Project Name')).toBe('my-project-name');
+  });
+
+  it('builds repo URL in the format used by the create command', () => {
+    // Create command builds https://github.com/${auth.username}/${repoName}
+    const username = 'testuser';
+    const repoName = sanitizeRepoName('@org/my-package');
+    const repoUrl = `https://github.com/${username}/${repoName}`;
+    expect(repoUrl).toBe('https://github.com/testuser/my-package');
+  });
+});

src/__tests__/github.test.ts

@@ -0,0 +1,183 @@
+jest.mock('execa');
+
+import { execa } from 'execa';
+import {
+  sanitizeRepoName,
+  checkGhAuth,
+  repoExists,
+  createRepo,
+} from '../github.js';
+
+const mockExeca = execa as jest.MockedFunction<typeof execa>;
+
+describe('sanitizeRepoName', () => {
+  it('returns lowercase name with invalid chars replaced by hyphen', () => {
+    expect(sanitizeRepoName('My Project')).toBe('my-project');
+    expect(sanitizeRepoName('my_project')).toBe('my_project');
+  });
+
+  it('strips npm scope and uses package name only', () => {
+    expect(sanitizeRepoName('@my-org/my-package')).toBe('my-package');
+    expect(sanitizeRepoName('@scope/package-name')).toBe('package-name');
+  });
+
+  it('collapses multiple hyphens', () => {
+    expect(sanitizeRepoName('my---project')).toBe('my-project');
+    expect(sanitizeRepoName('  spaces  ')).toBe('spaces');
+  });
+
+  it('strips leading and trailing hyphens', () => {
+    expect(sanitizeRepoName('--my-project--')).toBe('my-project');
+    expect(sanitizeRepoName('-single-')).toBe('single');
+  });
+
+  it('allows alphanumeric, hyphens, underscores, and dots', () => {
+    expect(sanitizeRepoName('my.project_1')).toBe('my.project_1');
+    expect(sanitizeRepoName('v1.0.0')).toBe('v1.0.0');
+  });
+
+  it('returns "my-project" when result would be empty', () => {
+    expect(sanitizeRepoName('@scope/---')).toBe('my-project');
+    expect(sanitizeRepoName('!!!')).toBe('my-project');
+  });
+
+  it('handles scoped package with only special chars after scope', () => {
+    expect(sanitizeRepoName('@org/---')).toBe('my-project');
+  });
+});
+
+describe('checkGhAuth', () => {
+  beforeEach(() => {
+    mockExeca.mockReset();
+  });
+
+  it('returns ok: false when gh auth status fails', async () => {
+    mockExeca.mockRejectedValueOnce(new Error('not logged in'));
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({
+      ok: false,
+      message: expect.stringContaining('GitHub CLI (gh) is not installed'),
+    });
+    expect(mockExeca).toHaveBeenCalledWith('gh', ['auth', 'status'], { reject: true });
+  });
+
+  it('returns ok: false when gh api user returns empty login', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockExeca.mockResolvedValueOnce({ stdout: '\n  \n', stderr: '', exitCode: 0 });
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({
+      ok: false,
+      message: expect.stringContaining('Could not determine your GitHub username'),
+    });
+  });
+
+  it('returns ok: false when gh api user throws', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockExeca.mockRejectedValueOnce(new Error('API error'));
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({
+      ok: false,
+      message: expect.stringContaining('Could not fetch your GitHub username'),
+    });
+  });
+
+  it('returns ok: true with username when auth and api succeed', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockExeca.mockResolvedValueOnce({
+      stdout: '  octocat  ',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({ ok: true, username: 'octocat' });
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'gh', ['api', 'user', '--jq', '.login'], {
+      encoding: 'utf8',
+    });
+  });
+});
+
+describe('repoExists', () => {
+  beforeEach(() => {
+    mockExeca.mockReset();
+  });
+
+  it('returns true when gh api repos/owner/repo succeeds', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '{}', stderr: '', exitCode: 0 });
+
+    const result = await repoExists('octocat', 'my-repo');
+
+    expect(result).toBe(true);
+    expect(mockExeca).toHaveBeenCalledWith('gh', ['api', 'repos/octocat/my-repo'], {
+      reject: true,
+    });
+  });
+
+  it('returns false when gh api throws (e.g. 404)', async () => {
+    mockExeca.mockRejectedValueOnce(new Error('Not Found'));
+
+    const result = await repoExists('octocat', 'nonexistent');
+
+    expect(result).toBe(false);
+  });
+});
+
+describe('createRepo', () => {
+  const projectPath = '/tmp/my-app';
+  const username = 'octocat';
+
+  beforeEach(() => {
+    mockExeca.mockReset();
+    mockExeca.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 } as Awaited<
+      ReturnType<typeof execa>
+    >);
+  });
+
+  it('calls gh repo create with expected args and returns repo URL', async () => {
+    const url = await createRepo({
+      repoName: 'my-app',
+      projectPath,
+      username,
+    });
+
+    expect(url).toBe('https://github.com/octocat/my-app.git');
+    expect(mockExeca).toHaveBeenCalledWith(
+      'gh',
+      [
+        'repo',
+        'create',
+        'my-app',
+        '--public',
+        '--source',
+        projectPath,
+        '--description',
+        '',
+        '--remote',
+        'origin',
+      ],
+      { stdio: 'inherit', cwd: projectPath },
+    );
+  });
+
+  it('passes description when provided', async () => {
+    await createRepo({
+      repoName: 'my-app',
+      projectPath,
+      username,
+      description: 'My cool project',
+    });
+
+    expect(mockExeca).toHaveBeenCalledWith(
+      'gh',
+      expect.arrayContaining(['--description', 'My cool project']),
+      expect.any(Object),
+    );
+  });
+});

src/cli.ts

@@ -5,8 +5,9 @@ import { execa } from 'execa';
 import inquirer from 'inquirer';
 import fs from 'fs-extra';
 import path from 'path';
-import { defaultTemplates }from './templates.js';
+import { defaultTemplates } from './templates.js';
 import { mergeTemplates } from './template-loader.js';
+import { checkGhAuth, createRepo, repoExists as ghRepoExists, sanitizeRepoName } from './github.js';
 
 /** Project data provided by the user */
 type ProjectData = {
@@ -171,6 +172,86 @@ program
       await execa(packageManager, ['install'], { cwd: projectPath, stdio: 'inherit' });
       console.log('✅ Dependencies installed.');
 
+      // Optional: Create GitHub repository
+      const { createGitHub } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'createGitHub',
+          message: 'Would you like to create a GitHub repository for this project?',
+          default: false,
+        },
+      ]);
+
+      if (createGitHub) {
+        const auth = await checkGhAuth();
+        if (!auth.ok) {
+          console.log(`\n⚠️  ${auth.message}`);
+          console.log('   Skipping GitHub repository creation.\n');
+        } else {
+          const pkgJsonForGh = await fs.readJson(pkgJsonPath);
+          const projectName = pkgJsonForGh.name as string;
+          let repoName = sanitizeRepoName(projectName);
+
+          // If repo already exists, ask for alternative name until we get one that doesn't exist or user skips
+          while (await ghRepoExists(auth.username, repoName)) {
+            console.log(`\n⚠️  A repository named "${repoName}" already exists on GitHub under your account.\n`);
+            const { alternativeName } = await inquirer.prompt([
+              {
+                type: 'input',
+                name: 'alternativeName',
+                message: 'Enter an alternative repository name (or leave empty to skip creating a GitHub repository):',
+                default: '',
+              },
+            ]);
+            if (!alternativeName?.trim()) {
+              repoName = '';
+              break;
+            }
+            repoName = sanitizeRepoName(alternativeName.trim());
+          }
+
+          if (repoName) {
+            const repoUrl = `https://github.com/${auth.username}/${repoName}`;
+            console.log('\n📋 The following will happen:\n');
+            console.log(`   • A new public repository will be created at: ${repoUrl}`);
+            console.log(`   • The repository will be created under your GitHub account (${auth.username}).`);
+            console.log(`   • The repository URL will be added to your package.json.`);
+            console.log(`   • The remote "origin" will be set to this repository (you can push when ready).\n`);
+
+            const { confirmCreate } = await inquirer.prompt([
+              {
+                type: 'confirm',
+                name: 'confirmCreate',
+                message: 'Do you want to proceed with creating this repository?',
+                default: true,
+              },
+            ]);
+
+            if (!confirmCreate) {
+              console.log('\n❌ GitHub repository was not created. Your local project is ready at:');
+              console.log(`   ${projectPath}\n`);
+            } else {
+              try {
+                const createdUrl = await createRepo({
+                  repoName,
+                  projectPath,
+                  username: auth.username,
+                  ...(pkgJsonForGh.description && { description: String(pkgJsonForGh.description) }),
+                });
+                pkgJsonForGh.repository = { type: 'git', url: createdUrl };
+                await fs.writeJson(pkgJsonPath, pkgJsonForGh, { spaces: 2 });
+                console.log('\n✅ GitHub repository created successfully!');
+                console.log(`   ${repoUrl}`);
+                console.log('   Repository URL has been added to your package.json.\n');
+              } catch (err) {
+                console.error('\n❌ Failed to create GitHub repository:');
+                if (err instanceof Error) console.error(`   ${err.message}\n`);
+              }
+            }
+          }
+        }
+      }
+
       // Let the user know the project was created successfully
       console.log('\n✨ Project created successfully! ✨\n');
       console.log(`To get started:`);