@patternfly/patternfly-cli 1.0.2

package/src/__tests__/save.test.ts

@@ -0,0 +1,272 @@
+jest.mock('fs-extra', () => ({
+  __esModule: true,
+  default: {
+    pathExists: jest.fn(),
+  },
+}));
+
+jest.mock('execa', () => ({
+  __esModule: true,
+  execa: jest.fn(),
+}));
+
+jest.mock('inquirer', () => ({
+  __esModule: true,
+  default: {
+    prompt: jest.fn(),
+  },
+}));
+
+jest.mock('../github.js', () => ({
+  offerAndCreateGitHubRepo: jest.fn(),
+}));
+
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import { offerAndCreateGitHubRepo } from '../github.js';
+import { runSave } from '../save.js';
+
+const mockPathExists = fs.pathExists as jest.MockedFunction<typeof fs.pathExists>;
+const mockExeca = execa as jest.MockedFunction<typeof execa>;
+const mockPrompt = inquirer.prompt as jest.MockedFunction<typeof inquirer.prompt>;
+const mockOfferAndCreateGitHubRepo = offerAndCreateGitHubRepo as jest.MockedFunction<typeof offerAndCreateGitHubRepo>;
+
+const cwd = '/tmp/my-repo';
+
+describe('runSave', () => {
+  const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    consoleErrorSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+  });
+
+  it('throws and logs error when .git directory does not exist', async () => {
+    mockPathExists.mockResolvedValue(false);
+
+    await expect(runSave(cwd)).rejects.toThrow('Not a git repository');
+    expect(mockPathExists).toHaveBeenCalledWith(`${cwd}/.git`);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('This directory is not a git repository'),
+    );
+    expect(mockExeca).not.toHaveBeenCalled();
+    expect(mockPrompt).not.toHaveBeenCalled();
+  });
+
+  it('logs "No changes to save" and returns when working tree is clean', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
+
+    await runSave(cwd);
+
+    expect(mockExeca).toHaveBeenCalledTimes(1);
+    expect(mockExeca).toHaveBeenCalledWith('git', ['status', '--porcelain'], {
+      cwd,
+      encoding: 'utf8',
+    });
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('No changes to save'),
+    );
+    expect(mockPrompt).not.toHaveBeenCalled();
+  });
+
+  it('logs "No changes to save" when status output is only whitespace', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockResolvedValue({ stdout: '  \n  ', stderr: '', exitCode: 0 });
+
+    await runSave(cwd);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('No changes to save'),
+    );
+    expect(mockPrompt).not.toHaveBeenCalled();
+  });
+
+  it('prompts to save; when user says no, logs "Nothing has been saved"', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockResolvedValue({ stdout: ' M file.ts', stderr: '', exitCode: 0 });
+    mockPrompt.mockResolvedValueOnce({ saveChanges: false });
+
+    await runSave(cwd);
+
+    expect(mockPrompt).toHaveBeenCalledTimes(1);
+    expect(mockPrompt).toHaveBeenCalledWith([
+      expect.objectContaining({
+        type: 'confirm',
+        name: 'saveChanges',
+        message: expect.stringContaining('Would you like to save them?'),
+      }),
+    ]);
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Nothing has been saved'),
+    );
+    expect(mockExeca).toHaveBeenCalledTimes(1); // only status, no add/commit/push
+  });
+
+  it('when user says yes but message is empty, logs "No message provided"', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockResolvedValue({ stdout: ' M file.ts', stderr: '', exitCode: 0 });
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: '   ' });
+
+    await runSave(cwd);
+
+    expect(mockPrompt).toHaveBeenCalledTimes(2);
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('No message provided'),
+    );
+    expect(mockExeca).toHaveBeenCalledTimes(1); // only status
+  });
+
+  it('when user says yes and provides message, runs add, commit, push and logs success', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: 'https://github.com/user/repo.git', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'Fix bug in save command' });
+
+    await runSave(cwd);
+
+    expect(mockExeca).toHaveBeenCalledTimes(5);
+    expect(mockExeca).toHaveBeenNthCalledWith(1, 'git', ['status', '--porcelain'], {
+      cwd,
+      encoding: 'utf8',
+    });
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'git', ['add', '.'], {
+      cwd,
+      stdio: 'inherit',
+    });
+    expect(mockExeca).toHaveBeenNthCalledWith(3, 'git', [
+      'commit',
+      '-m',
+      'Fix bug in save command',
+    ], { cwd, stdio: 'inherit' });
+    expect(mockExeca).toHaveBeenNthCalledWith(4, 'git', ['remote', 'get-url', 'origin'], expect.any(Object));
+    expect(mockExeca).toHaveBeenNthCalledWith(5, 'git', ['push'], {
+      cwd,
+      stdio: 'inherit',
+    });
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Changes saved and pushed to GitHub successfully'),
+    );
+  });
+
+  it('throws and logs push-failure message when push fails with exitCode 128', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: 'https://github.com/user/repo.git', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(Object.assign(new Error('push failed'), { exitCode: 128 }));
+
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'WIP' });
+
+    await expect(runSave(cwd)).rejects.toMatchObject({ message: 'push failed' });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Push failed'),
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('remote'),
+    );
+  });
+
+  it('throws and logs generic failure when add/commit/push fails with other exitCode', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(Object.assign(new Error('add failed'), { exitCode: 1 }));
+
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'WIP' });
+
+    await expect(runSave(cwd)).rejects.toMatchObject({ message: 'add failed' });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Save or push failed'),
+    );
+  });
+
+  it('throws and logs error when execa throws without exitCode', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: 'https://github.com/user/repo.git', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('network error'));
+
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'WIP' });
+
+    await expect(runSave(cwd)).rejects.toThrow('network error');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('An error occurred'),
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('network error'),
+    );
+  });
+
+  it('when no remote origin, offers to create GitHub repo and throws if user does not create', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no remote'));
+    mockOfferAndCreateGitHubRepo.mockResolvedValue(false);
+
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'WIP' });
+
+    await expect(runSave(cwd)).rejects.toThrow('No remote origin');
+    expect(mockOfferAndCreateGitHubRepo).toHaveBeenCalledWith(cwd);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Set a remote'),
+    );
+    expect(mockExeca).not.toHaveBeenCalledWith('git', ['push'], expect.any(Object));
+  });
+
+  it('when no remote origin and user creates GitHub repo, pushes successfully', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca
+      .mockResolvedValueOnce({ stdout: ' M file.ts', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no remote'))
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockOfferAndCreateGitHubRepo.mockResolvedValue(true);
+
+    mockPrompt
+      .mockResolvedValueOnce({ saveChanges: true })
+      .mockResolvedValueOnce({ message: 'WIP' });
+
+    await runSave(cwd);
+
+    expect(mockOfferAndCreateGitHubRepo).toHaveBeenCalledWith(cwd);
+    expect(mockExeca).toHaveBeenCalledWith('git', ['push'], { cwd, stdio: 'inherit' });
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Changes saved and pushed to GitHub successfully'),
+    );
+  });
+});

package/src/cli.ts

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import fs from 'fs-extra';
+import path from 'path';
+import { defaultTemplates } from './templates.js';
+import { mergeTemplates } from './template-loader.js';
+import { offerAndCreateGitHubRepo } from './github.js';
+import { runSave } from './save.js';
+import { runLoad } from './load.js';
+
+/** Project data provided by the user */
+type ProjectData = {
+  /** Project name */
+  name: string, 
+  /** Project version */
+  version: string,
+  /** Project description */
+  description: string,
+  /** Project author */
+  author: string
+}
+
+/** Command to create a new project */
+program
+  .version('1.0.0')
+  .command('create')
+  .description('Create a new project from a git template')
+  .argument('[project-directory]', 'The directory to create the project in')
+  .argument('[template-name]', 'The name of the template to use')
+  .option('-t, --template-file <path>', 'Path to a JSON file with custom templates (same format as built-in)')
+  .option('--ssh', 'Use SSH URL for cloning the template repository')
+  .action(async (projectDirectory, templateName, options) => {
+    const templatesToUse = mergeTemplates(defaultTemplates, options?.templateFile);
+
+    // If project directory is not provided, prompt for it
+    if (!projectDirectory) {
+      const projectDirAnswer = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'projectDirectory',
+          message: 'Please provide the directory where you want to create the project?',
+          default: 'my-app',
+        },
+      ]);
+      projectDirectory = projectDirAnswer.projectDirectory;
+    }
+
+    // If template name is not provided, show available templates and let user select
+    if (!templateName) {
+      console.log('\n📋 Available templates:\n');
+      templatesToUse.forEach(t => {
+        console.log(`  ${t.name.padEnd(12)} - ${t.description}`);
+      });
+      console.log('');
+      
+      const templateQuestion = [
+        {
+          type: 'list',
+          name: 'templateName',
+          message: 'Select a template:',
+          choices: templatesToUse.map(t => ({
+            name: `${t.name} - ${t.description}`,
+            value: t.name
+          }))
+        }
+      ];
+      
+      const templateAnswer = await inquirer.prompt(templateQuestion);
+      templateName = templateAnswer.templateName;
+    }
+    
+    // Look up the template by name
+    const template = templatesToUse.find(t => t.name === templateName);
+    if (!template) {
+      console.error(`❌ Template "${templateName}" not found.\n`);
+      console.log('📋 Available templates:\n');
+      templatesToUse.forEach(t => {
+        console.log(`  ${t.name.padEnd(12)} - ${t.description}`);
+      });
+      console.log('');
+      process.exit(1);
+    }
+
+    // If --ssh was not passed, prompt whether to use SSH
+    let useSSH = options?.ssh;
+    if (useSSH === undefined && template.repoSSH) {
+      const sshAnswer = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useSSH',
+          message: 'Use SSH URL for cloning?',
+          default: false,
+        },
+      ]);
+      useSSH = sshAnswer.useSSH;
+    }
+
+    const templateRepoUrl = useSSH && template.repoSSH ? template.repoSSH : template.repo;
+    
+    // Define the full path for the new project
+    const projectPath = path.resolve(projectDirectory);
+    console.log(`Cloning template "${templateName}" from ${templateRepoUrl} into ${projectPath}...`);
+
+    try {
+      
+      // Clone the repository
+      const cloneArgs = ['clone'];
+      if (template.options && Array.isArray(template.options)) {
+        cloneArgs.push(...template.options);
+      }
+      cloneArgs.push(templateRepoUrl, projectPath);
+      await execa('git', cloneArgs, { stdio: 'inherit' });
+      console.log('✅ Template cloned successfully.');
+
+      // Remove the .git folder from the *new* project
+      await fs.remove(path.join(projectPath, '.git'));
+      console.log('🧹 Cleaned up template .git directory.');
+
+      // Ask user for customization details
+      const questions = [
+        {
+          type: 'input',
+          name: 'name',
+          message: 'What is the project name?',
+          default: path.basename(projectPath),
+        },
+        {
+          type: 'input',
+          name: 'version',
+          message: 'What version number would you like to use?',
+          default: '1.0.0',
+        },
+        {
+          type: 'input',
+          name: 'description',
+          message: 'What is the project description?',
+          default: '',
+        },
+        {
+          type: 'input',
+          name: 'author',
+          message: 'Who is the author of the project?',
+          default: '',
+        },
+      ];
+
+      const answers: ProjectData = await inquirer.prompt(questions);
+
+      // Update the package.json in the new project
+      const pkgJsonPath = path.join(projectPath, 'package.json');
+      
+      if (await fs.pathExists(pkgJsonPath)) {
+        const pkgJson = await fs.readJson(pkgJsonPath);
+        
+        // Overwrite fields with user's answers
+        pkgJson.name = answers.name;
+        pkgJson.version = answers.version;
+        pkgJson.description = answers.description;
+        pkgJson.author = answers.author;
+        
+        // Write the updated package.json back
+        await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+        console.log('📝 Customized package.json.');
+      } else {
+        console.log('ℹ️ No package.json found in template, skipping customization.');
+      }
+
+      const packageManager = template.packageManager || "npm";
+      // Install dependencies
+      console.log('📦 Installing dependencies... (This may take a moment)');
+      await execa(packageManager, ['install'], { cwd: projectPath, stdio: 'inherit' });
+      console.log('✅ Dependencies installed.');
+
+      // Optional: Create GitHub repository
+      await offerAndCreateGitHubRepo(projectPath);
+
+      // Let the user know the project was created successfully
+      console.log('\n✨ Project created successfully! ✨\n');
+      console.log(`To get started:`);
+      console.log(`  cd ${projectDirectory}`);
+      console.log('  Happy coding! 🚀');
+
+    } catch (error) {
+      console.error('❌ An error occurred:');
+      if (error instanceof Error) {
+        console.error(error.message);
+      } else if (error && typeof error === 'object' && 'stderr' in error) {
+        console.error((error as { stderr?: string }).stderr || String(error));
+      } else {
+        console.error(String(error));
+      }
+      
+      // Clean up the created directory if an error occurred
+      if (await fs.pathExists(projectPath)) {
+        await fs.remove(projectPath);
+        console.log('🧹 Cleaned up failed project directory.');
+      }
+    }
+  });
+
+/** Command to initialize a project and optionally create a GitHub repository */
+program
+  .command('init')
+  .description('Initialize the current directory (or path) as a git repo and optionally create a GitHub repository')
+  .argument('[path]', 'Path to the project directory (defaults to current directory)')
+  .action(async (dirPath) => {
+    const cwd = dirPath ? path.resolve(dirPath) : process.cwd();
+    const gitDir = path.join(cwd, '.git');
+    if (!(await fs.pathExists(gitDir))) {
+      await execa('git', ['init'], { stdio: 'inherit', cwd });
+      console.log('✅ Git repository initialized.\n');
+    }
+    await offerAndCreateGitHubRepo(cwd);
+  });
+
+/** Command to list all available templates */
+program
+  .command('list')
+  .description('List all available templates')
+  .option('--verbose', 'List all available templates with verbose information')
+  .option('-t, --template-file <path>', 'Include templates from a JSON file (same format as built-in)')
+  .action((options) => {
+    const templatesToUse = mergeTemplates(defaultTemplates, options?.templateFile);
+    console.log('\n📋 Available templates:\n');
+    templatesToUse.forEach(template => {
+      console.log(`  ${template.name.padEnd(20)} - ${template.description}`)
+      if (options.verbose) {
+        console.log(`    Repo URL: ${template.repo}`);
+        if (template.options && Array.isArray(template.options)) {
+          console.log(`    Checkout Options: ${template.options.join(', ')}`);
+        }
+      }
+    });
+    console.log('');
+  });
+
+/** Command to run PatternFly codemods on a directory */
+program
+  .command('update')
+  .description('Run PatternFly codemods on a directory to transform code to the latest PatternFly patterns')
+  .argument('[path]', 'The path to the source directory to run codemods on (defaults to "src")')
+  .option('--fix', 'Automatically apply fixes to files instead of just showing what would be changed')
+  .action(async (srcPath, options) => {
+    const targetPath = srcPath || 'src';
+    const resolvedPath = path.resolve(targetPath);
+    const commands = ['@patternfly/pf-codemods', '@patternfly/class-name-updater'];
+    
+    console.log(`Running PatternFly updates on ${resolvedPath}...`);
+
+    for (const command of commands) {
+      try {
+        console.log(`\n📦 Running ${command}...`);
+        const args = [command];
+        if (options.fix) {
+          args.push('--fix');
+        }
+        args.push(resolvedPath);
+        await execa('npx', args, { stdio: 'inherit' });
+        console.log(`✅ ${command} completed successfully.`);
+      } catch (error) {
+        console.error(`❌ An error occurred while running ${command}:`);
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else if (error && typeof error === 'object' && 'stderr' in error) {
+          console.error((error as { stderr?: string }).stderr || String(error));
+        } else {
+          console.error(String(error));
+        }
+        process.exit(1);
+      }
+    }
+    
+    console.log('\n✨ All updates completed successfully! ✨');
+  });
+
+/** Command to save changes: check for changes, prompt to commit, and push */
+program
+  .command('save')
+  .description('Check for changes, optionally commit them with a message, and push to the current branch')
+  .argument('[path]', 'Path to the repository (defaults to current directory)')
+  .action(async (repoPath) => {
+    const cwd = repoPath ? path.resolve(repoPath) : process.cwd();
+    try {
+      await runSave(cwd);
+    } catch {
+      process.exit(1);
+    }
+  });
+
+/** Command to load latest updates from the remote */
+program
+  .command('load')
+  .description('Pull the latest updates from GitHub')
+  .argument('[path]', 'Path to the repository (defaults to current directory)')
+  .action(async (repoPath) => {
+    const cwd = repoPath ? path.resolve(repoPath) : process.cwd();
+    try {
+      await runLoad(cwd);
+    } catch {
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);