@nemus-cli/nemus 0.8.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/config-schema.test.ts

@@ -7,6 +7,8 @@ import {
   parseConfigValue,
   applyConfigSet,
   applyConfigUnset,
+  validateTypedValue,
+  reviewConfigFileText,
   formatConfigValue,
 } from './config-schema';
 
@@ -95,6 +97,53 @@ describe('applyConfigSet / applyConfigUnset (pure, immutable)', () => {
   });
 });
 
+describe('validateTypedValue (already-typed, as from the JSON file)', () => {
+  it('accepts correctly-typed values', () => {
+    expect(validateTypedValue('autoReportBugs', true)).toEqual({ ok: true });
+    expect(validateTypedValue('cloneProtocol', 'https')).toEqual({ ok: true });
+    expect(validateTypedValue('githubOrg', '')).toEqual({ ok: true }); // allowEmpty
+    expect(validateTypedValue('workspacesDir', '/x')).toEqual({ ok: true });
+  });
+  it('rejects wrong types and bad enum/empty values', () => {
+    expect(validateTypedValue('autoReportBugs', 'yes').ok).toBe(false); // string, not boolean
+    expect(validateTypedValue('cloneProtocol', 'ftp').ok).toBe(false);
+    expect(validateTypedValue('cloneProtocol', 42 as unknown).ok).toBe(false);
+    expect(validateTypedValue('workspacesDir', '   ').ok).toBe(false); // required, blank
+    expect(validateTypedValue('installMcp', 1 as unknown).ok).toBe(false);
+  });
+});
+
+describe('reviewConfigFileText (for `config edit`)', () => {
+  it('flags unparseable JSON', () => {
+    const r = reviewConfigFileText('{ not json');
+    expect(r.parseError).toBe(true);
+    expect(r.ok).toBe(false);
+  });
+  it('flags non-object JSON (null / array / scalar) without throwing', () => {
+    for (const t of ['null', '42', '"str"', '[1,2]']) {
+      const r = reviewConfigFileText(t);
+      expect(r.notObject).toBe(true);
+      expect(r.ok).toBe(false);
+      expect(r.unknownKeys).toEqual([]); // no numeric-index "keys" from an array
+    }
+  });
+  it('reports unknown keys but stays ok if known values are valid', () => {
+    const r = reviewConfigFileText(JSON.stringify({ githubOrg: 'acme', bogus: 1, nope: true }));
+    expect(r.unknownKeys.sort()).toEqual(['bogus', 'nope']);
+    expect(r.ok).toBe(true);
+  });
+  it('catches invalid VALUES the same way config set would', () => {
+    const r = reviewConfigFileText(JSON.stringify({ cloneProtocol: 'ftp', autoReportBugs: 'yes' }));
+    expect(r.ok).toBe(false);
+    expect(r.invalid.join('\n')).toMatch(/cloneProtocol must be one of/);
+    expect(r.invalid.join('\n')).toMatch(/autoReportBugs must be a boolean/);
+  });
+  it('accepts a clean object', () => {
+    const r = reviewConfigFileText(JSON.stringify({ cloneProtocol: 'https', installMcp: true }));
+    expect(r).toMatchObject({ parseError: false, notObject: false, unknownKeys: [], invalid: [], ok: true });
+  });
+});
+
 describe('formatConfigValue', () => {
   it('renders booleans and empty strings predictably', () => {
     expect(formatConfigValue(true)).toBe('true');

package/src/utils/config-schema.ts

@@ -80,6 +80,29 @@ export function parseConfigValue(key: ConfigKey, raw: string): ParseResult {
   return { ok: true, value: trimmed };
 }
 
+/**
+ * Validate an already-typed value (as it appears in the JSON config file) for
+ * `key` against its field spec. This is the parse-free sibling of
+ * parseConfigValue (which coerces a CLI string): it checks that a boolean field
+ * holds a boolean, an enum holds an allowed string, and a string field holds a
+ * (non-empty, unless allowEmpty) string. Used by `config edit` so a hand-edit
+ * is validated the same way `config set` validates. Pure + unit-tested.
+ */
+export function validateTypedValue(key: ConfigKey, value: unknown): { ok: true } | { ok: false; error: string } {
+  const spec: FieldSpec = CONFIG_SCHEMA[key];
+  if (spec.type === 'boolean') {
+    return typeof value === 'boolean' ? { ok: true } : { ok: false, error: `${key} must be a boolean` };
+  }
+  if (spec.type === 'enum') {
+    return typeof value === 'string' && (spec.values as readonly string[]).includes(value)
+      ? { ok: true }
+      : { ok: false, error: `${key} must be one of: ${spec.values.join(', ')}` };
+  }
+  if (typeof value !== 'string') return { ok: false, error: `${key} must be a string` };
+  if (!spec.allowEmpty && value.trim() === '') return { ok: false, error: `${key} cannot be empty` };
+  return { ok: true };
+}
+
 /** Apply a `set` to a config object, returning a NEW config or an error. Pure. */
 export function applyConfigSet(
   current: UserConfig,
@@ -110,3 +133,45 @@ export function applyConfigUnset(
 export function formatConfigValue(value: unknown): string {
   return typeof value === 'boolean' ? String(value) : String(value ?? '');
 }
+
+export interface ConfigFileReview {
+  /** JSON.parse failed. */
+  parseError: boolean;
+  /** Parsed, but not a plain object (null / array / scalar). */
+  notObject: boolean;
+  /** Keys present in the file that aren't recognized config keys. */
+  unknownKeys: string[];
+  /** Validation error messages for known keys holding invalid values. */
+  invalid: string[];
+  /** True when the file is a usable config object (may still have warnings). */
+  ok: boolean;
+}
+
+/**
+ * Review the raw text of a hand-edited config file the same way `config set`
+ * validates: it must parse, be a plain object, only use known keys, and every
+ * known key present must hold a schema-valid value. Pure so `config edit` can be
+ * fully unit-tested without spawning an editor.
+ */
+export function reviewConfigFileText(text: string): ConfigFileReview {
+  const base = { parseError: false, notObject: false, unknownKeys: [] as string[], invalid: [] as string[] };
+  let raw: unknown;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { ...base, parseError: true, ok: false };
+  }
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    return { ...base, notObject: true, ok: false };
+  }
+  const obj = raw as Record<string, unknown>;
+  const known = new Set<string>(CONFIG_KEYS);
+  const unknownKeys = Object.keys(obj).filter((k) => !known.has(k));
+  const invalid: string[] = [];
+  for (const key of CONFIG_KEYS) {
+    if (!(key in obj)) continue;
+    const res = validateTypedValue(key, obj[key]);
+    if (!res.ok) invalid.push(res.error);
+  }
+  return { parseError: false, notObject: false, unknownKeys, invalid, ok: invalid.length === 0 };
+}

package/src/utils/editor.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect, vi } from 'vitest';
+import { resolveEditor, openInEditor } from './editor';
+
+describe('resolveEditor', () => {
+  it('prefers $VISUAL over $EDITOR', () => {
+    expect(resolveEditor({ VISUAL: 'code --wait', EDITOR: 'vim' }, 'darwin')).toEqual(['code', '--wait']);
+  });
+  it('falls back to $EDITOR, splitting flags', () => {
+    expect(resolveEditor({ EDITOR: 'emacs -nw' }, 'linux')).toEqual(['emacs', '-nw']);
+  });
+  it('platform default when neither is set', () => {
+    expect(resolveEditor({}, 'win32')).toEqual(['notepad']);
+    expect(resolveEditor({}, 'linux')).toEqual(['vi']);
+    expect(resolveEditor({ EDITOR: '   ' }, 'darwin')).toEqual(['vi']); // blank ignored
+  });
+});
+
+describe('openInEditor', () => {
+  it('launches editor argv[0] + flags + file, inheriting stdio', () => {
+    const spawn = vi.fn().mockReturnValue({ status: 0 }) as any;
+    const res = openInEditor('/tmp/config.json', { spawn, env: { EDITOR: 'code --wait' }, platform: 'darwin' });
+    expect(spawn).toHaveBeenCalledWith('code', ['--wait', '/tmp/config.json'], { stdio: 'inherit' });
+    expect(res).toEqual({ ok: true, editor: 'code', code: 0 });
+  });
+
+  it('reports a non-zero editor exit as not-ok', () => {
+    const spawn = vi.fn().mockReturnValue({ status: 1 }) as any;
+    expect(openInEditor('/f', { spawn, env: { EDITOR: 'vi' } }).ok).toBe(false);
+  });
+
+  it('reports a missing editor (ENOENT) with a clear message', () => {
+    const spawn = vi.fn().mockReturnValue({ error: Object.assign(new Error('x'), { code: 'ENOENT' }) }) as any;
+    const res = openInEditor('/f', { spawn, env: { EDITOR: 'nope' } });
+    expect(res.ok).toBe(false);
+    expect(res.error).toMatch(/not found/);
+  });
+});

package/src/utils/editor.ts

@@ -0,0 +1,48 @@
+import { spawnSync } from 'child_process';
+
+/**
+ * Resolve the user's preferred editor as an argv array. Honors `$VISUAL` then
+ * `$EDITOR` (the long-standing Unix convention — `VISUAL` wins for full-screen
+ * editors), falling back to `notepad` on Windows and `vi` elsewhere. The env
+ * value may include flags (e.g. `code --wait`, `emacs -nw`), so it's split on
+ * whitespace into a command + args. Pure + unit-tested.
+ */
+export function resolveEditor(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string[] {
+  const raw = (env.VISUAL || env.EDITOR || '').trim();
+  if (raw) return raw.split(/\s+/);
+  return platform === 'win32' ? ['notepad'] : ['vi'];
+}
+
+export interface EditorResult {
+  ok: boolean;
+  /** Editor argv[0] that was launched. */
+  editor: string;
+  /** Process exit code, when the editor ran and exited normally. */
+  code?: number;
+  /** Populated when the editor couldn't be launched at all. */
+  error?: string;
+}
+
+/**
+ * Open `file` in the resolved editor, inheriting the terminal so the editor is
+ * interactive. Returns a structured result rather than throwing so the caller
+ * controls messaging/exit. `spawn` is injected for tests.
+ */
+export function openInEditor(
+  file: string,
+  deps: { spawn?: typeof spawnSync; env?: NodeJS.ProcessEnv; platform?: NodeJS.Platform } = {},
+): EditorResult {
+  const spawn = deps.spawn ?? spawnSync;
+  const [cmd, ...args] = resolveEditor(deps.env, deps.platform);
+  const res = spawn(cmd, [...args, file], { stdio: 'inherit' });
+  if (res.error) {
+    const err = res.error as NodeJS.ErrnoException;
+    const reason = err.code === 'ENOENT' ? `editor "${cmd}" not found` : err.message;
+    return { ok: false, editor: cmd, error: reason };
+  }
+  const code = typeof res.status === 'number' ? res.status : 1;
+  return { ok: code === 0, editor: cmd, code };
+}

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