@nemus-cli/nemus 0.9.0 → 0.11.0

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) {

package/src/utils/prune.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import {
+  toCandidate,
+  isStale,
+  protectionReason,
+  planPrune,
+  type WorkspaceForPrune,
+  type PruneCandidate,
+} from './prune';
+import type { GitStatus } from '../types';
+
+const NOW = Date.parse('2026-09-01T00:00:00Z');
+const daysAgo = (n: number) => NOW - n * 24 * 60 * 60 * 1000;
+
+function ws(over: Partial<WorkspaceForPrune> = {}): WorkspaceForPrune {
+  return { name: 'w', path: '/w', repoDirNames: [], lastActiveAt: 0, createdAt: 0, ...over };
+}
+function status(over: Partial<GitStatus> = {}): GitStatus {
+  return {
+    repo: 'r', branch: 'main', clean: true, ahead: 0, behind: 0,
+    modifiedFiles: 0, untrackedFiles: 0, hasRemote: true, detachedHead: false, ...over,
+  };
+}
+
+describe('toCandidate', () => {
+  it('prefers lastActive over createdAt and marks fromSession', () => {
+    const c = toCandidate(ws({ lastActiveAt: daysAgo(5), createdAt: daysAgo(40) }), NOW);
+    expect(c.fromSession).toBe(true);
+    expect(c.ageDays).toBe(5);
+    expect(c.undatable).toBe(false);
+  });
+
+  it('falls back to createdAt when there is no session', () => {
+    const c = toCandidate(ws({ lastActiveAt: 0, createdAt: daysAgo(40) }), NOW);
+    expect(c.fromSession).toBe(false);
+    expect(c.ageDays).toBe(40);
+  });
+
+  it('is undatable when neither timestamp is present', () => {
+    const c = toCandidate(ws({ lastActiveAt: 0, createdAt: 0 }), NOW);
+    expect(c.undatable).toBe(true);
+    expect(c.ageDays).toBe(0);
+  });
+
+  it('floors a future reference to a negative age (clock skew) without marking undatable', () => {
+    const c = toCandidate(ws({ lastActiveAt: NOW + 60_000 }), NOW);
+    expect(c.undatable).toBe(false);
+    expect(c.ageDays).toBeLessThan(0);
+  });
+});
+
+describe('isStale', () => {
+  const c = (over: Partial<WorkspaceForPrune>) => toCandidate(ws(over), NOW);
+
+  it('is true at or beyond the threshold', () => {
+    expect(isStale(c({ lastActiveAt: daysAgo(30) }), 30)).toBe(true);
+    expect(isStale(c({ lastActiveAt: daysAgo(31) }), 30)).toBe(true);
+  });
+  it('is false below the threshold', () => {
+    expect(isStale(c({ lastActiveAt: daysAgo(29) }), 30)).toBe(false);
+  });
+  it('never selects an undatable workspace', () => {
+    expect(isStale(c({ lastActiveAt: 0, createdAt: 0 }), 0)).toBe(false);
+  });
+  it('never selects a future-dated (skewed) workspace', () => {
+    expect(isStale(c({ lastActiveAt: NOW + 86_400_000 }), 0)).toBe(false);
+  });
+});
+
+describe('protectionReason', () => {
+  it('returns null for an all-clean workspace', () => {
+    expect(protectionReason([status(), status()], false)).toBeNull();
+  });
+  it('returns null for an empty workspace', () => {
+    expect(protectionReason([], false)).toBeNull();
+  });
+  it('flags uncommitted changes', () => {
+    expect(protectionReason([status({ clean: false })], false)).toBe('1 repo with uncommitted changes');
+  });
+  it('flags unpushed commits', () => {
+    expect(protectionReason([status({ ahead: 2 })], false)).toBe('1 repo with unpushed commits');
+  });
+  it('combines both reasons and pluralizes', () => {
+    expect(
+      protectionReason([status({ clean: false }), status({ clean: false }), status({ ahead: 1 })], false),
+    ).toBe('2 repos with uncommitted changes, 1 repo with unpushed commits');
+  });
+  it('returns null when includeDirty overrides protection', () => {
+    expect(protectionReason([status({ clean: false, ahead: 3 })], true)).toBeNull();
+  });
+});
+
+describe('planPrune', () => {
+  const mk = (name: string, repos: string[]): PruneCandidate =>
+    toCandidate(ws({ name, path: `/w/${name}`, repoDirNames: repos, lastActiveAt: daysAgo(40) }), NOW);
+
+  it('partitions prunable vs protected and skips git calls for empty workspaces', async () => {
+    const empty = mk('empty', []);
+    const clean = mk('clean', ['a']);
+    const dirty = mk('dirty', ['b']);
+    let calls = 0;
+    const resolver = async (c: PruneCandidate): Promise<GitStatus[]> => {
+      calls++;
+      return c.name === 'dirty' ? [status({ clean: false })] : [status()];
+    };
+
+    const plan = await planPrune([empty, clean, dirty], resolver, false);
+
+    expect(plan.prunable.map((c) => c.name)).toEqual(['empty', 'clean']);
+    expect(plan.protected.map((p) => p.candidate.name)).toEqual(['dirty']);
+    expect(plan.protected[0].reason).toBe('1 repo with uncommitted changes');
+    expect(calls).toBe(2); // empty workspace incurred no status call
+  });
+
+  it('includeDirty moves everything to prunable', async () => {
+    const dirty = mk('dirty', ['b']);
+    const plan = await planPrune([dirty], async () => [status({ clean: false, ahead: 2 })], true);
+    expect(plan.prunable.map((c) => c.name)).toEqual(['dirty']);
+    expect(plan.protected).toHaveLength(0);
+  });
+});