@nemus-cli/nemus 0.2.1

package/src/commands/suite/create.ts

@@ -0,0 +1,240 @@
+#!/usr/bin/env ts-node
+
+import { verifyGhAuth, fetchOrgRepos, displayAuthInstructions } from '../../utils/github';
+import { promptRepositorySelection, promptWorkspaceSelection } from '../../utils/prompts';
+import { listWorkspaces } from '../../utils/workspace-meta';
+import { logInfo, logSuccess, logError, logStep } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import { saveSuite, getSuite, validateSuiteName } from '../../utils/suite';
+import { SuiteEntry, WorkspaceSuite, PostCloneHook } from '../../types';
+import inquirer from 'inquirer';
+
+async function promptSuiteDetails(defaultName?: string): Promise<{ name: string; description: string }> {
+  const { name, description } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Suite name:',
+      default: defaultName,
+      validate: (input: string) => validateSuiteName(input.trim()),
+      filter: (input: string) => input.trim(),
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Suite description (optional):',
+    },
+  ]);
+
+  return { name, description: description || '' };
+}
+
+async function promptPostCloneHooks(): Promise<PostCloneHook[] | undefined> {
+  const { addHooks } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'addHooks',
+      message: 'Add post-clone hooks?',
+      default: false,
+    },
+  ]);
+
+  if (!addHooks) return undefined;
+
+  const commands: string[] = [];
+  console.log('Enter commands one at a time. Type "done" when finished.\n');
+
+  while (true) {
+    const { command } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'command',
+        message: `Command ${commands.length + 1} (or "done"):`,
+      },
+    ]);
+
+    if (command.trim().toLowerCase() === 'done') break;
+    if (command.trim()) {
+      commands.push(command.trim());
+    }
+  }
+
+  if (commands.length === 0) return undefined;
+
+  return [{
+    commands,
+    continueOnError: true,
+  }];
+}
+
+async function checkOverwrite(name: string): Promise<boolean> {
+  const existing = await getSuite(name);
+  if (!existing) return true;
+
+  const { overwrite } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'overwrite',
+      message: `Suite "${name}" already exists (${existing.entries.length} repos). Overwrite?`,
+      default: false,
+    },
+  ]);
+
+  return overwrite;
+}
+
+async function createInteractive() {
+  // Step 1: Verify gh CLI authentication
+  logStep(1, 4, 'Verifying GitHub CLI authentication...');
+  const isAuthenticated = await verifyGhAuth();
+
+  if (!isAuthenticated) {
+    logError('GitHub CLI is not authenticated');
+    displayAuthInstructions();
+    process.exit(1);
+  }
+
+  logSuccess('GitHub CLI authenticated');
+
+  // Step 2: Fetch repos
+  logStep(2, 4, 'Fetching repositories...');
+  const forceRefresh = process.argv.includes('--force-refresh') || process.argv.includes('-f');
+  const repos = await fetchOrgRepos({ forceRefresh });
+
+  if (repos.length === 0) {
+    logError('No repositories found');
+    process.exit(1);
+  }
+
+  // Step 3: Select repositories
+  logStep(3, 4, 'Select repositories for the suite...');
+  const selections = await promptRepositorySelection(repos);
+
+  const entries: SuiteEntry[] = selections.map(s => ({
+    repoName: s.repo.name,
+    directoryName: s.directoryName,
+  }));
+
+  // Step 4: Name and save
+  logStep(4, 5, 'Enter suite details...');
+  const { name, description } = await promptSuiteDetails();
+
+  if (!(await checkOverwrite(name))) {
+    logInfo('Suite creation cancelled');
+    process.exit(0);
+  }
+
+  // Step 5: Optional hooks
+  logStep(5, 5, 'Post-clone hooks (optional)...');
+  const postCloneHooks = await promptPostCloneHooks();
+
+  const existing = await getSuite(name);
+  const now = new Date().toISOString();
+  const suite: WorkspaceSuite = {
+    name,
+    description,
+    entries,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+    ...(postCloneHooks && { postCloneHooks }),
+  };
+
+  await saveSuite(suite);
+  logSuccess(`Suite "${colorize(name, 'cyan')}" created with ${entries.length} repositories`);
+}
+
+async function createFromWorkspace() {
+  // Step 1: Select workspace
+  logStep(1, 3, 'Select a workspace...');
+  const workspaces = await listWorkspaces();
+
+  if (workspaces.length === 0) {
+    logError('No workspaces found. Create one first with: workspace create');
+    process.exit(1);
+  }
+
+  const workspaceName = await promptWorkspaceSelection(workspaces);
+  const workspace = workspaces.find(ws => ws.name === workspaceName);
+
+  if (!workspace?.metadata) {
+    logError('No metadata found for this workspace');
+    process.exit(1);
+  }
+
+  const entries: SuiteEntry[] = workspace.metadata.repositories
+    .filter(r => r.status === 'success')
+    .map(r => ({
+      repoName: r.name,
+      directoryName: r.directoryName,
+    }));
+
+  console.log(`\n${colorize('Repositories from workspace:', 'cyan')} ${entries.length}`);
+  for (const e of entries) {
+    const alias = e.directoryName !== e.repoName ? ` (${e.repoName})` : '';
+    console.log(`  - ${e.directoryName}${alias}`);
+  }
+  console.log('');
+
+  // Step 2: Name and save
+  logStep(2, 4, 'Enter suite details...');
+  const { name, description } = await promptSuiteDetails(workspaceName);
+
+  if (!(await checkOverwrite(name))) {
+    logInfo('Suite creation cancelled');
+    process.exit(0);
+  }
+
+  // Step 3: Optional hooks
+  logStep(3, 4, 'Post-clone hooks (optional)...');
+  const postCloneHooks = await promptPostCloneHooks();
+
+  const existing = await getSuite(name);
+  const now = new Date().toISOString();
+  const suite: WorkspaceSuite = {
+    name,
+    description,
+    entries,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+    ...(postCloneHooks && { postCloneHooks }),
+  };
+
+  // Step 4: Save
+  logStep(4, 4, 'Saving suite...');
+  await saveSuite(suite);
+  logSuccess(`Suite "${colorize(name, 'cyan')}" created with ${entries.length} repositories`);
+}
+
+export async function main() {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Create Suite', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const { mode } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'mode',
+        message: 'How would you like to create the suite?',
+        choices: [
+          { name: 'Pick repositories interactively', value: 'interactive' },
+          { name: 'Save from an existing workspace', value: 'workspace' },
+        ],
+      },
+    ]);
+
+    if (mode === 'interactive') {
+      await createInteractive();
+    } else {
+      await createFromWorkspace();
+    }
+  } catch (error) {
+    logError('Failed to create suite');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();

package/src/commands/suite/delete.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env ts-node
+
+import { listSuites, deleteSuite } from '../../utils/suite';
+import { logInfo, logSuccess, logError } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import inquirer from 'inquirer';
+
+export async function main() {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Delete Suite', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const suites = await listSuites();
+
+    if (suites.length === 0) {
+      logInfo('No suites found');
+      process.exit(0);
+    }
+
+    const { suiteName } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'suiteName',
+        message: 'Select a suite to delete:',
+        choices: suites.map(s => ({
+          name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
+          value: s.name,
+          short: s.name,
+        })),
+        pageSize: 15,
+      },
+    ]);
+
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: `Are you sure you want to delete suite "${suiteName}"?`,
+        default: false,
+      },
+    ]);
+
+    if (!confirmed) {
+      logInfo('Deletion cancelled');
+      process.exit(0);
+    }
+
+    const deleted = await deleteSuite(suiteName);
+
+    if (deleted) {
+      logSuccess(`Suite "${colorize(suiteName, 'cyan')}" deleted`);
+    } else {
+      logError(`Suite "${suiteName}" not found`);
+    }
+  } catch (error) {
+    logError('Failed to delete suite');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();

package/src/commands/suite/export.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env ts-node
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { listSuites, exportSuite, exportAllSuites } from '../../utils/suite';
+import { logInfo, logSuccess, logError } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import inquirer from 'inquirer';
+
+export async function main(opts?: { file?: string }) {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Export Suite', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const suites = await listSuites();
+
+    if (suites.length === 0) {
+      logInfo('No suites found');
+      process.exit(0);
+    }
+
+    const { mode } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'mode',
+        message: 'What would you like to export?',
+        choices: [
+          { name: 'A single suite', value: 'single' },
+          { name: 'All suites', value: 'all' },
+        ],
+      },
+    ]);
+
+    let data;
+    let defaultFilename: string;
+
+    if (mode === 'single') {
+      const { suiteName } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'suiteName',
+          message: 'Select a suite to export:',
+          choices: suites.map(s => ({
+            name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
+            value: s.name,
+            short: s.name,
+          })),
+          pageSize: 15,
+        },
+      ]);
+
+      data = await exportSuite(suiteName);
+      if (!data) {
+        logError(`Suite "${suiteName}" not found`);
+        process.exit(1);
+      }
+
+      defaultFilename = `${suiteName}-suite.json`;
+    } else {
+      data = await exportAllSuites();
+      defaultFilename = 'all-suites.json';
+    }
+
+    const outputArg = opts?.file;
+    let outputPath: string;
+
+    if (outputArg && !outputArg.startsWith('-')) {
+      outputPath = path.resolve(outputArg);
+    } else {
+      const { filePath } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'filePath',
+          message: 'Output file path:',
+          default: `./${defaultFilename}`,
+        },
+      ]);
+      outputPath = path.resolve(filePath);
+    }
+
+    await fs.writeFile(outputPath, JSON.stringify(data, null, 2), 'utf-8');
+    logSuccess(`Exported to ${colorize(outputPath, 'cyan')}`);
+
+    const suiteCount = data.suites.length;
+    const totalRepos = data.suites.reduce((sum, s) => sum + s.entries.length, 0);
+    console.log(`  ${suiteCount} suite(s), ${totalRepos} total repositories\n`);
+  } catch (error) {
+    logError('Failed to export suite');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();

package/src/commands/suite/import.ts

@@ -0,0 +1,100 @@
+#!/usr/bin/env ts-node
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { importSuites } from '../../utils/suite';
+import { logInfo, logSuccess, logError, logWarning } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+import { SuitesStore } from '../../types';
+import inquirer from 'inquirer';
+
+export async function main(opts?: { file?: string }) {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Import Suite', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const fileArg = opts?.file;
+    let filePath: string;
+
+    if (fileArg && !fileArg.startsWith('-')) {
+      filePath = path.resolve(fileArg);
+    } else {
+      const { inputPath } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'inputPath',
+          message: 'Path to suite JSON file:',
+          validate: (input: string) => input.trim().length > 0 || 'File path is required',
+        },
+      ]);
+      filePath = path.resolve(inputPath);
+    }
+
+    let content: string;
+    try {
+      content = await fs.readFile(filePath, 'utf-8');
+    } catch {
+      logError(`Could not read file: ${filePath}`);
+      process.exit(1);
+    }
+
+    let data: SuitesStore;
+    try {
+      data = JSON.parse(content);
+    } catch {
+      logError('Invalid JSON file');
+      process.exit(1);
+    }
+
+    if (!data.suites || !Array.isArray(data.suites)) {
+      logError('Invalid suite file format: missing "suites" array');
+      process.exit(1);
+    }
+
+    console.log(`Found ${colorize(String(data.suites.length), 'yellow')} suite(s):\n`);
+    for (const suite of data.suites) {
+      console.log(`  ${colorize(suite.name, 'cyan')} (${suite.entries?.length ?? 0} repos)`);
+      if (suite.description) {
+        console.log(`    ${suite.description}`);
+      }
+    }
+    console.log('');
+
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: 'Overwrite existing suites with the same name?',
+        default: false,
+      },
+    ]);
+
+    const result = await importSuites(data, overwrite);
+
+    if (result.imported.length > 0) {
+      logSuccess(`Imported: ${result.imported.join(', ')}`);
+    }
+
+    if (result.skipped.length > 0) {
+      logInfo(`Skipped (already exist): ${result.skipped.join(', ')}`);
+    }
+
+    if (result.errors.length > 0) {
+      logWarning('Errors:');
+      for (const err of result.errors) {
+        logError(`  ${err}`);
+      }
+    }
+
+    console.log('');
+  } catch (error) {
+    logError('Failed to import suite');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();

package/src/commands/suite/index.ts

@@ -0,0 +1,66 @@
+import { Command } from 'commander';
+import { getGlobalOpts } from '../../utils/command-helpers';
+
+export function registerSuiteCommands(parent: Command) {
+  const suite = parent
+    .command('suite')
+    .description('Suite management');
+
+  suite
+    .command('create')
+    .description('Create a new suite (pick repos or save from workspace)')
+    .action(async () => {
+      const { main } = await import('./create');
+      await main();
+    });
+
+  suite
+    .command('list')
+    .description('List all saved suites')
+    .action(async () => {
+      const { main } = await import('./list');
+      await main();
+    });
+
+  suite
+    .command('delete')
+    .description('Delete a suite')
+    .action(async () => {
+      const { main } = await import('./delete');
+      await main();
+    });
+
+  suite
+    .command('export')
+    .description('Export suite(s) to JSON file for sharing')
+    .argument('[file]', 'Output file path')
+    .action(async (file) => {
+      const { main } = await import('./export');
+      await main({ file });
+    });
+
+  suite
+    .command('import')
+    .description('Import suite(s) from JSON file')
+    .argument('[file]', 'Input file path')
+    .action(async (file) => {
+      const { main } = await import('./import');
+      await main({ file });
+    });
+
+  suite
+    .command('use')
+    .description('Create workspace from a suite')
+    .option('-s, --suite <name>', 'Suite name')
+    .option('-w, --workspace <name>', 'Workspace name')
+    .action(async (opts, cmd) => {
+      const globalOpts = getGlobalOpts(cmd);
+      const { main } = await import('./use');
+      await main({
+        suite: opts.suite,
+        workspace: opts.workspace,
+        yes: globalOpts.yes,
+        forceRefresh: globalOpts.forceRefresh,
+      });
+    });
+}

package/src/commands/suite/list.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env ts-node
+
+import { listSuites } from '../../utils/suite';
+import { logInfo, logError } from '../../utils/logger';
+import { colorize } from '../../utils/colors';
+
+export async function main() {
+  console.log('\n' + '='.repeat(60));
+  console.log(colorize('Saved Suites', 'bright'));
+  console.log('='.repeat(60) + '\n');
+
+  try {
+    const suites = await listSuites();
+
+    if (suites.length === 0) {
+      logInfo('No suites found');
+      console.log('\nCreate a new suite with:');
+      console.log('  workspace suite-create\n');
+      return;
+    }
+
+    for (const suite of suites) {
+      console.log(colorize(suite.name, 'cyan'));
+      if (suite.description) {
+        console.log(`  ${suite.description}`);
+      }
+      console.log(`  Repositories: ${colorize(String(suite.entries.length), 'yellow')}`);
+
+      for (const entry of suite.entries) {
+        const alias = entry.directoryName !== entry.repoName ? ` (${entry.repoName})` : '';
+        console.log(`    - ${entry.directoryName}${alias}`);
+      }
+
+      const createdDate = new Date(suite.createdAt).toLocaleString();
+      const updatedDate = new Date(suite.updatedAt).toLocaleString();
+      console.log(`  Created: ${createdDate}`);
+      if (suite.updatedAt !== suite.createdAt) {
+        console.log(`  Updated: ${updatedDate}`);
+      }
+
+      console.log('');
+    }
+
+    console.log('='.repeat(60) + '\n');
+  } catch (error) {
+    logError('Failed to list suites');
+    if (error instanceof Error) {
+      logError(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();