@nemus-cli/nemus 0.9.0 → 0.10.0

package/src/commands/suite/use.ts

@@ -13,7 +13,7 @@ import { colorize } from '../../utils/colors';
 import { listSuites } from '../../utils/suite';
 import { runPostCloneHooks } from '../../utils/hooks';
 import { GitHubRepo } from '../../types';
-import inquirer from 'inquirer';
+import { select } from '../../utils/prompt';
 import { validateWorkspaceName, checkWorkspaceExists, sanitizeWorkspaceName, resolveWorkspaceNameConflict } from '../../utils/validation';
 
 export interface SuiteUseOpts {
@@ -64,19 +64,14 @@ export async function main(opts?: SuiteUseOpts) {
       }
       selectedSuite = found;
     } else {
-      const { suite } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'suite',
-          message: 'Select a suite:',
-          choices: suites.map(s => ({
-            name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
-            value: s,
-            short: s.name,
-          })),
-          pageSize: 15,
-        },
-      ]);
+      const suite = await select({
+        message: 'Select a suite:',
+        choices: suites.map(s => ({
+          name: `${s.name} (${s.entries.length} repos)${s.description ? ` - ${s.description}` : ''}`,
+          value: s,
+        })),
+        pageSize: 15,
+      });
       selectedSuite = suite;
     }
 

package/src/utils/prompt.ts

@@ -0,0 +1,16 @@
+/**
+ * Interactive prompt primitives.
+ *
+ * We depend on the modular `@inquirer/prompts` (the maintained successor to the
+ * classic `inquirer` package and its `inquirer-autocomplete-prompt` plugin).
+ * All prompt call sites import from HERE, not from `@inquirer/prompts` directly,
+ * so there is a single place to:
+ *   - centralize the ESM-only package (loaded from our CommonJS build via
+ *     Node 22's stable `require(esm)` — the CLI requires Node >= 22), and
+ *   - stub prompts in tests (mock '../utils/prompt').
+ *
+ * The classic array API (`inquirer.prompt([{ type, name, message }])` returning
+ * `{ name: value }`) is replaced by these functions, which take an options
+ * object and return the answer VALUE directly.
+ */
+export { confirm, input, select, checkbox, password, search, Separator } from '@inquirer/prompts';

package/src/utils/prompts.test.ts

@@ -1,19 +1,20 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-const { mockPrompt } = vi.hoisted(() => ({
-  mockPrompt: vi.fn(),
+const { mockSearch, mockInput } = vi.hoisted(() => ({
+  mockSearch: vi.fn(),
+  mockInput: vi.fn(),
 }));
 
-// Mock inquirer before imports
-vi.mock('inquirer', () => ({
-  default: {
-    prompt: mockPrompt,
-    registerPrompt: vi.fn(),
-  },
-}));
-
-vi.mock('inquirer-autocomplete-prompt', () => ({
-  default: {},
+// Mock the modular prompt module. promptMultiWorkspaceSelection uses search();
+// the modular API returns the selected VALUE directly (not { name: value }).
+vi.mock('./prompt', () => ({
+  search: mockSearch,
+  input: mockInput,
+  confirm: vi.fn(),
+  select: vi.fn(),
+  checkbox: vi.fn(),
+  password: vi.fn(),
+  Separator: class {},
 }));
 
 vi.mock('fuzzy', () => ({
@@ -35,7 +36,8 @@ vi.mock('./validation', () => ({
   sanitizeWorkspaceName: vi.fn((input: string) => input),
 }));
 
-import { promptMultiWorkspaceSelection } from './prompts';
+import { promptMultiWorkspaceSelection, promptWorkspaceName } from './prompts';
+import { validateWorkspaceName, sanitizeWorkspaceName } from './validation';
 
 const makeWorkspaces = (...names: string[]) =>
   names.map(name => ({
@@ -44,6 +46,33 @@ const makeWorkspaces = (...names: string[]) =>
     metadata: { repositories: [], createdAt: new Date().toISOString() },
   }));
 
+describe('promptWorkspaceName', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  it('validates the SANITIZED name, not the raw input (classic filter-before-validate parity)', async () => {
+    // Classic inquirer ran filter (sanitize) BEFORE validate, so a name like
+    // "My Workspace" was validated as "my-workspace". Regression guard.
+    (sanitizeWorkspaceName as any).mockImplementation((s: string) =>
+      s.trim().toLowerCase().replace(/ +/g, '-'));
+    (validateWorkspaceName as any).mockReturnValue(true);
+
+    mockInput.mockImplementation(async (opts: any) => {
+      // Simulate the user submitting a raw value containing a space.
+      opts.validate('My Workspace');
+      return 'My Workspace';
+    });
+
+    const result = await promptWorkspaceName();
+
+    // validate must have seen the sanitized value, and the return is sanitized.
+    expect(validateWorkspaceName).toHaveBeenCalledWith('my-workspace');
+    expect(result).toBe('my-workspace');
+  });
+});
+
 describe('promptMultiWorkspaceSelection', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -51,10 +80,10 @@ describe('promptMultiWorkspaceSelection', () => {
   });
 
   it('returns selected workspace names', async () => {
-    mockPrompt
-      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
-      .mockResolvedValueOnce({ workspaceName: 'ws-beta' })
-      .mockResolvedValueOnce({ workspaceName: 'done' });
+    mockSearch
+      .mockResolvedValueOnce('ws-alpha')
+      .mockResolvedValueOnce('ws-beta')
+      .mockResolvedValueOnce('done');
 
     const result = await promptMultiWorkspaceSelection(
       makeWorkspaces('ws-alpha', 'ws-beta', 'ws-gamma')
@@ -65,10 +94,10 @@ describe('promptMultiWorkspaceSelection', () => {
 
   it('requires at least one selection before accepting done', async () => {
     // First "done" should be rejected, then select one, then done
-    mockPrompt
-      .mockResolvedValueOnce({ workspaceName: 'done' })
-      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
-      .mockResolvedValueOnce({ workspaceName: 'done' });
+    mockSearch
+      .mockResolvedValueOnce('done')
+      .mockResolvedValueOnce('ws-alpha')
+      .mockResolvedValueOnce('done');
 
     const result = await promptMultiWorkspaceSelection(
       makeWorkspaces('ws-alpha', 'ws-beta')
@@ -76,13 +105,13 @@ describe('promptMultiWorkspaceSelection', () => {
 
     expect(result).toEqual(['ws-alpha']);
     // Should have prompted 3 times (done rejected, select, done accepted)
-    expect(mockPrompt).toHaveBeenCalledTimes(3);
+    expect(mockSearch).toHaveBeenCalledTimes(3);
   });
 
   it('auto-completes when all workspaces are selected', async () => {
-    mockPrompt
-      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
-      .mockResolvedValueOnce({ workspaceName: 'ws-beta' });
+    mockSearch
+      .mockResolvedValueOnce('ws-alpha')
+      .mockResolvedValueOnce('ws-beta');
 
     const result = await promptMultiWorkspaceSelection(
       makeWorkspaces('ws-alpha', 'ws-beta')
@@ -90,13 +119,13 @@ describe('promptMultiWorkspaceSelection', () => {
 
     expect(result).toEqual(['ws-alpha', 'ws-beta']);
     // Only 2 prompts needed - loop breaks when no available names left
-    expect(mockPrompt).toHaveBeenCalledTimes(2);
+    expect(mockSearch).toHaveBeenCalledTimes(2);
   });
 
   it('returns single workspace selection', async () => {
-    mockPrompt
-      .mockResolvedValueOnce({ workspaceName: 'ws-only' })
-      .mockResolvedValueOnce({ workspaceName: 'done' });
+    mockSearch
+      .mockResolvedValueOnce('ws-only')
+      .mockResolvedValueOnce('done');
 
     const result = await promptMultiWorkspaceSelection(
       makeWorkspaces('ws-only', 'ws-other')
@@ -110,7 +139,7 @@ describe('promptMultiWorkspaceSelection', () => {
       throw new Error('process.exit');
     });
 
-    mockPrompt.mockRejectedValueOnce(new Error('User force closed'));
+    mockSearch.mockRejectedValueOnce(new Error('User force closed'));
 
     await expect(
       promptMultiWorkspaceSelection(makeWorkspaces('ws-alpha'))
@@ -122,9 +151,9 @@ describe('promptMultiWorkspaceSelection', () => {
 
   it('prints summary with correct singular form', async () => {
     const logSpy = vi.spyOn(console, 'log');
-    mockPrompt
-      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
-      .mockResolvedValueOnce({ workspaceName: 'done' });
+    mockSearch
+      .mockResolvedValueOnce('ws-alpha')
+      .mockResolvedValueOnce('done');
 
     await promptMultiWorkspaceSelection(makeWorkspaces('ws-alpha', 'ws-beta'));
 
@@ -136,10 +165,10 @@ describe('promptMultiWorkspaceSelection', () => {
 
   it('prints summary with correct plural form', async () => {
     const logSpy = vi.spyOn(console, 'log');
-    mockPrompt
-      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
-      .mockResolvedValueOnce({ workspaceName: 'ws-beta' })
-      .mockResolvedValueOnce({ workspaceName: 'done' });
+    mockSearch
+      .mockResolvedValueOnce('ws-alpha')
+      .mockResolvedValueOnce('ws-beta')
+      .mockResolvedValueOnce('done');
 
     await promptMultiWorkspaceSelection(
       makeWorkspaces('ws-alpha', 'ws-beta', 'ws-gamma')
@@ -153,10 +182,10 @@ describe('promptMultiWorkspaceSelection', () => {
 
   it('prints green confirmation after each selection', async () => {
     const logSpy = vi.spyOn(console, 'log');
-    mockPrompt
-      .mockResolvedValueOnce({ workspaceName: 'ws-alpha' })
-      .mockResolvedValueOnce({ workspaceName: 'ws-beta' })
-      .mockResolvedValueOnce({ workspaceName: 'done' });
+    mockSearch
+      .mockResolvedValueOnce('ws-alpha')
+      .mockResolvedValueOnce('ws-beta')
+      .mockResolvedValueOnce('done');
 
     await promptMultiWorkspaceSelection(
       makeWorkspaces('ws-alpha', 'ws-beta', 'ws-gamma')

package/src/utils/prompts.ts

@@ -1,13 +1,9 @@
-import inquirer from 'inquirer';
-import autocompletePrompt from 'inquirer-autocomplete-prompt';
+import { confirm, input, select, search } from './prompt';
 import * as fuzzy from 'fuzzy';
 import { GitHubRepo } from '../types';
 import { validateWorkspaceName, checkWorkspaceExists, sanitizeWorkspaceName } from './validation';
 import { colorize } from './colors';
 
-// Register autocomplete prompt type
-inquirer.registerPrompt('autocomplete', autocompletePrompt);
-
 export interface RepoSelection {
   repo: GitHubRepo;
   directoryName: string;
@@ -17,32 +13,28 @@ export const promptInstanceSuffix = async (
   repoName: string,
   existingDirectoryNames: string[]
 ): Promise<string> => {
-  const { suffix } = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'suffix',
-      message: `"${repoName}" already exists. Enter a suffix for this instance:`,
-      validate: (input: string) => {
-        if (!input || input.trim().length === 0) {
-          return 'Suffix cannot be empty';
-        }
+  const suffix = await input({
+    message: `"${repoName}" already exists. Enter a suffix for this instance:`,
+    validate: (input: string) => {
+      if (!input || input.trim().length === 0) {
+        return 'Suffix cannot be empty';
+      }
 
-        const trimmed = input.trim();
+      const trimmed = input.trim();
 
-        // Validate characters (alphanumeric, hyphens, underscores)
-        if (!/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
-          return 'Suffix can only contain letters, numbers, hyphens, and underscores';
-        }
+      // Validate characters (alphanumeric, hyphens, underscores)
+      if (!/^[a-zA-Z0-9_-]+$/.test(trimmed)) {
+        return 'Suffix can only contain letters, numbers, hyphens, and underscores';
+      }
 
-        const candidateName = `${repoName}-${trimmed}`;
-        if (existingDirectoryNames.includes(candidateName)) {
-          return `"${candidateName}" already exists. Choose a different suffix`;
-        }
+      const candidateName = `${repoName}-${trimmed}`;
+      if (existingDirectoryNames.includes(candidateName)) {
+        return `"${candidateName}" already exists. Choose a different suffix`;
+      }
 
-        return true;
-      },
+      return true;
     },
-  ]);
+  });
 
   return suffix.trim();
 };
@@ -63,43 +55,39 @@ export const promptRepositorySelection = async (
 
   while (true) {
     try {
-      const { repoName } = await inquirer.prompt([
-        {
-          type: 'autocomplete',
-          name: 'repoName',
-          message: `Search and select repository (${colorize(String(selectedEntries.length), 'cyan')} selected):`,
-          source: async (_answersSoFar: any, input: string | undefined) => {
-            const searchInput = input || '';
-
-            // Always include done option
-            const doneOption = { name: colorize('done - Finish selection', 'green'), value: 'done' };
-
-            // If no input or "done" typed, show done + top repos
-            if (!searchInput || searchInput.toLowerCase().startsWith('done')) {
-              return [
-                doneOption,
-                ...repos.slice(0, 15).map(repo => ({
-                  name: `${repo.name}${repo.description ? ` - ${colorize(repo.description, 'gray')}` : ''}`,
-                  value: repo.name,
-                }))
-              ];
-            }
-
-            // Perform fuzzy search
-            const results = fuzzy.filter(searchInput, repos, {
-              extract: (repo) => `${repo.name} ${repo.description || ''}`,
-            });
-
-            const suggestions = results.slice(0, 15).map(result => ({
-              name: `${result.original.name}${result.original.description ? ` - ${colorize(result.original.description, 'gray')}` : ''}`,
-              value: result.original.name,
-            }));
-
-            return [doneOption, ...suggestions];
-          },
-          pageSize: 16,
-        } as any,
-      ]);
+      const repoName = await search<string>({
+        message: `Search and select repository (${colorize(String(selectedEntries.length), 'cyan')} selected):`,
+        pageSize: 16,
+        source: async (term: string | undefined) => {
+          const searchInput = term || '';
+
+          // Always include done option
+          const doneOption = { name: colorize('done - Finish selection', 'green'), value: 'done' };
+
+          // If no input or "done" typed, show done + top repos
+          if (!searchInput || searchInput.toLowerCase().startsWith('done')) {
+            return [
+              doneOption,
+              ...repos.slice(0, 15).map(repo => ({
+                name: `${repo.name}${repo.description ? ` - ${colorize(repo.description, 'gray')}` : ''}`,
+                value: repo.name,
+              }))
+            ];
+          }
+
+          // Perform fuzzy search
+          const results = fuzzy.filter(searchInput, repos, {
+            extract: (repo) => `${repo.name} ${repo.description || ''}`,
+          });
+
+          const suggestions = results.slice(0, 15).map(result => ({
+            name: `${result.original.name}${result.original.description ? ` - ${colorize(result.original.description, 'gray')}` : ''}`,
+            value: result.original.name,
+          }));
+
+          return [doneOption, ...suggestions];
+        },
+      });
 
       if (repoName === 'done') {
         if (selectedEntries.length === 0) {
@@ -147,23 +135,18 @@ export const promptRepositorySelection = async (
 };
 
 export const promptWorkspaceName = async (): Promise<string> => {
-  const { workspaceName } = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'workspaceName',
-      message: 'Enter workspace name:',
-      validate: (input: string) => {
-        const validationResult = validateWorkspaceName(input);
-        if (validationResult !== true) {
-          return validationResult;
-        }
-        return true;
-      },
-      filter: (input: string) => sanitizeWorkspaceName(input),
+  const raw = await input({
+    message: 'Enter workspace name:',
+    validate: (value: string) => {
+      const validationResult = validateWorkspaceName(sanitizeWorkspaceName(value));
+      if (validationResult !== true) {
+        return validationResult;
+      }
+      return true;
     },
-  ]);
+  });
 
-  return workspaceName;
+  return sanitizeWorkspaceName(raw);
 };
 
 export const confirmWorkspaceCreation = async (
@@ -179,14 +162,10 @@ export const confirmWorkspaceCreation = async (
   console.log(`Repositories: ${colorize(String(repoCount), 'yellow')}`);
   console.log('='.repeat(60) + '\n');
 
-  const { confirmed } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'confirmed',
-      message: 'Create workspace with these settings?',
-      default: true,
-    },
-  ]);
+  const confirmed = await confirm({
+    message: 'Create workspace with these settings?',
+    default: true,
+  });
 
   return confirmed;
 };
@@ -201,18 +180,13 @@ export const promptWorkspaceSelection = async (workspaces: Array<{ name: string;
       ? `${ws.name} (${ws.metadata.repositories.length} repos)`
       : ws.name,
     value: ws.name,
-    short: ws.name,
   }));
 
-  const { workspaceName } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'workspaceName',
-      message: 'Select workspace to update:',
-      choices,
-      pageSize: 15,
-    },
-  ]);
+  const workspaceName = await select<string>({
+    message: 'Select workspace to update:',
+    choices,
+    pageSize: 15,
+  });
 
   return workspaceName;
 };
@@ -236,38 +210,34 @@ export const promptMultiWorkspaceSelection = async (
         break;
       }
 
-      const { workspaceName } = await inquirer.prompt([
-        {
-          type: 'autocomplete',
-          name: 'workspaceName',
-          message: `Search and select workspace (${colorize(String(selectedNames.length), 'cyan')} selected):`,
-          source: async (_answersSoFar: any, input: string | undefined) => {
-            const searchInput = input || '';
-
-            const doneOption = { name: colorize('done - Finish selection', 'green'), value: 'done' };
-
-            if (!searchInput || searchInput.toLowerCase().startsWith('done')) {
-              return [
-                doneOption,
-                ...availableNames.slice(0, 15).map(name => ({
-                  name,
-                  value: name,
-                }))
-              ];
-            }
-
-            const results = fuzzy.filter(searchInput, availableNames);
-
-            const suggestions = results.slice(0, 15).map(result => ({
-              name: result.original,
-              value: result.original,
-            }));
-
-            return [doneOption, ...suggestions];
-          },
-          pageSize: 16,
-        } as any,
-      ]);
+      const workspaceName = await search<string>({
+        message: `Search and select workspace (${colorize(String(selectedNames.length), 'cyan')} selected):`,
+        pageSize: 16,
+        source: async (term: string | undefined) => {
+          const searchInput = term || '';
+
+          const doneOption = { name: colorize('done - Finish selection', 'green'), value: 'done' };
+
+          if (!searchInput || searchInput.toLowerCase().startsWith('done')) {
+            return [
+              doneOption,
+              ...availableNames.slice(0, 15).map(name => ({
+                name,
+                value: name,
+              }))
+            ];
+          }
+
+          const results = fuzzy.filter(searchInput, availableNames);
+
+          const suggestions = results.slice(0, 15).map(result => ({
+            name: result.original,
+            value: result.original,
+          }));
+
+          return [doneOption, ...suggestions];
+        },
+      });
 
       if (workspaceName === 'done') {
         if (selectedNames.length === 0) {