@nemus-cli/nemus 0.2.9 → 0.2.11

package/src/utils/ghq-integration.test.ts

@@ -1,6 +1,15 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 const mockExecAsync = vi.fn();
+const mockExecFile = vi.fn();
+// ghqRepoExists now uses fs.stat (not `test -d`); cleanup uses fs.rm.
+const mockStat = vi.fn();
+const mockRm = vi.fn().mockResolvedValue(undefined);
+vi.mock('fs/promises', () => ({
+  stat: (...a: unknown[]) => mockStat(...a),
+  rm: (...a: unknown[]) => mockRm(...a),
+}));
+const cached = () => mockStat.mockResolvedValue({ isDirectory: () => true });
 vi.mock('child_process', () => ({
   exec: (...args: unknown[]) => {
     const callback = args[args.length - 1] as (err: Error | null, result: { stdout: string; stderr: string }) => void;
@@ -10,6 +19,18 @@ vi.mock('child_process', () => ({
       .then((result: { stdout: string; stderr: string }) => callback(null, result))
       .catch((err: Error) => callback(err, { stdout: '', stderr: '' }));
   },
+  // execFile(file, args, [opts], cb): reconstruct a command string so existing
+  // expectations that assert on the command keep working, and record argv.
+  execFile: (...args: unknown[]) => {
+    const callback = args[args.length - 1] as (err: Error | null, result: { stdout: string; stderr: string }) => void;
+    const file = args[0] as string;
+    const fileArgs = Array.isArray(args[1]) ? (args[1] as string[]) : [];
+    const opts = typeof args[2] === 'object' && args[2] !== null ? args[2] : {};
+    mockExecFile(file, fileArgs, opts);
+    mockExecAsync([file, ...fileArgs].join(' '), opts)
+      .then((result: { stdout: string; stderr: string }) => callback(null, result))
+      .catch((err: Error) => callback(err, { stdout: '', stderr: '' }));
+  },
 }));
 
 vi.mock('./logger', () => ({
@@ -28,13 +49,16 @@ import { cloneWithGhq, describeCloneError } from './ghq-integration';
 describe('cloneWithGhq', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    mockRm.mockResolvedValue(undefined);
+    // default: not cached (fs.stat rejects) unless a test opts into cached()
+    mockStat.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
   });
 
   it('uses git clone --local from ghq cache when repo exists', async () => {
+    cached();
     mockExecAsync.mockImplementation((cmd: string) => {
       if (cmd === 'which ghq') return Promise.resolve({ stdout: '/usr/bin/ghq\n', stderr: '' });
       if (cmd === 'ghq root') return Promise.resolve({ stdout: '/home/user/ghq\n', stderr: '' });
-      if (cmd.startsWith('test -d')) return Promise.resolve({ stdout: '', stderr: '' });
       if (cmd.startsWith('git clone --local')) return Promise.resolve({ stdout: '', stderr: '' });
       if (cmd.startsWith('git remote set-url')) return Promise.resolve({ stdout: '', stderr: '' });
       return Promise.resolve({ stdout: '', stderr: '' });
@@ -55,10 +79,10 @@ describe('cloneWithGhq', () => {
   });
 
   it('does not call ghq get -u when repo is already cached', async () => {
+    cached();
     mockExecAsync.mockImplementation((cmd: string) => {
       if (cmd === 'which ghq') return Promise.resolve({ stdout: '/usr/bin/ghq\n', stderr: '' });
       if (cmd === 'ghq root') return Promise.resolve({ stdout: '/home/user/ghq\n', stderr: '' });
-      if (cmd.startsWith('test -d')) return Promise.resolve({ stdout: '', stderr: '' });
       if (cmd.startsWith('git clone --local')) return Promise.resolve({ stdout: '', stderr: '' });
       if (cmd.startsWith('git remote set-url')) return Promise.resolve({ stdout: '', stderr: '' });
       return Promise.resolve({ stdout: '', stderr: '' });
@@ -109,8 +133,8 @@ describe('cloneWithGhq', () => {
     const calls = mockExecAsync.mock.calls.map(([cmd]: [string]) => cmd);
     // Should NOT attempt git clone --local since ghq get failed
     expect(calls.some((cmd: string) => cmd.includes('--local'))).toBe(false);
-    // Should fall back to direct clone
-    expect(calls.some((cmd: string) => cmd.startsWith('git clone "git@github.com'))).toBe(true);
+    // Should fall back to direct clone (argv form: no shell quotes)
+    expect(calls.some((cmd: string) => cmd.startsWith('git clone git@github.com'))).toBe(true);
   });
 
   it('falls back to direct git clone when ghq is not installed', async () => {
@@ -126,7 +150,7 @@ describe('cloneWithGhq', () => {
     expect(result.usedGhq).toBe(false);
 
     const calls = mockExecAsync.mock.calls.map(([cmd]: [string]) => cmd);
-    expect(calls.some((cmd: string) => cmd.startsWith('git clone "git@github.com'))).toBe(true);
+    expect(calls.some((cmd: string) => cmd.startsWith('git clone git@github.com'))).toBe(true);
     expect(calls.some((cmd: string) => cmd.includes('--local'))).toBe(false);
   });
 

package/src/utils/ghq-integration.ts

@@ -1,11 +1,16 @@
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 import * as path from 'path';
+import * as fs from 'fs/promises';
 import { logInfo, logSuccess, logWarning } from './logger';
 import { colorize } from './colors';
 import { CLONE_TIMEOUT_MS, CLONE_MAX_BUFFER } from './config';
 
-const execAsync = promisify(exec);
+// execFile (no shell): every value below (repo URLs, ghq paths, branch names)
+// is passed as an argv element, so none can be interpreted as a shell command.
+const execFileAsync = promisify(execFile);
+type ExecOpts = { cwd?: string; timeout?: number; maxBuffer?: number };
+const git = (args: string[], opts: ExecOpts = {}) => execFileAsync('git', args, opts);
 
 /**
  * Turn a raw child-process clone failure (from exec or execFile) into an
@@ -39,7 +44,7 @@ export function describeCloneError(error: unknown, timeoutMs: number = CLONE_TIM
  */
 export async function isGhqInstalled(): Promise<boolean> {
   try {
-    await execAsync('which ghq');
+    await execFileAsync('which', ['ghq']);
     return true;
   } catch {
     return false;
@@ -65,7 +70,7 @@ export async function warnIfGhqMissing(): Promise<boolean> {
  */
 export async function getGhqRoot(): Promise<string | null> {
   try {
-    const { stdout } = await execAsync('ghq root');
+    const { stdout } = await execFileAsync('ghq', ['root']);
     return stdout.trim();
   } catch {
     return null;
@@ -80,8 +85,8 @@ export async function ghqRepoExists(repoUrl: string): Promise<boolean> {
     const repoPath = await getGhqRepoPath(repoUrl);
     if (!repoPath) return false;
 
-    await execAsync(`test -d "${repoPath}"`);
-    return true;
+    const stat = await fs.stat(repoPath);
+    return stat.isDirectory();
   } catch {
     return false;
   }
@@ -114,7 +119,7 @@ export async function ghqGet(repoUrl: string): Promise<{ success: boolean; path?
   try {
     logInfo(`Using ghq to clone ${colorize(repoUrl, 'cyan')}...`);
 
-    await execAsync(`ghq get "${repoUrl}"`, { timeout: CLONE_TIMEOUT_MS, maxBuffer: CLONE_MAX_BUFFER });
+    await execFileAsync('ghq', ['get', repoUrl], { timeout: CLONE_TIMEOUT_MS, maxBuffer: CLONE_MAX_BUFFER });
 
     const repoPath = await getGhqRepoPath(repoUrl);
     if (!repoPath) {
@@ -135,7 +140,7 @@ export async function ghqGet(repoUrl: string): Promise<{ success: boolean; path?
  */
 export async function ghqList(): Promise<string[]> {
   try {
-    const { stdout } = await execAsync('ghq list');
+    const { stdout } = await execFileAsync('ghq', ['list']);
     return stdout.trim().split('\n').filter(line => line.length > 0);
   } catch {
     return [];
@@ -196,18 +201,15 @@ export async function cloneWithGhq(
         // would serve stale state via hardlinks — user would open a workspace
         // missing dozens of recent commits.
         try {
-          await execAsync(
-            `git -C "${sourcePath}" fetch origin --quiet --prune`,
-            { timeout: 90 * 1000 },
-          );
+          await git(['-C', sourcePath, 'fetch', 'origin', '--quiet', '--prune'], { timeout: 90 * 1000 });
         } catch {
           // Network failure or no upstream — fall through with stale cache,
           // we'll log a warning after the local clone if we can't align to HEAD.
         }
 
-        await execAsync(`git clone --local "${sourcePath}" "${targetPath}"`, { timeout: 60 * 1000 });
+        await git(['clone', '--local', sourcePath, targetPath], { timeout: 60 * 1000 });
         // Reset remote to point to the original repo URL (not the local ghq path)
-        await execAsync(`git remote set-url origin "${repoUrl}"`, { cwd: targetPath });
+        await git(['remote', 'set-url', 'origin', repoUrl], { cwd: targetPath });
 
         // Make sure the working tree is at origin's default-branch tip.
         // Robust against:
@@ -217,27 +219,25 @@ export async function cloneWithGhq(
         let alignedToHead = false;
         let alignError: string | null = null;
         try {
-          await execAsync(`git fetch origin --quiet`, { cwd: targetPath, timeout: 60 * 1000 });
+          await git(['fetch', 'origin', '--quiet'], { cwd: targetPath, timeout: 60 * 1000 });
 
           // Explicitly set refs/remotes/origin/HEAD by querying the remote.
           // Without this, symbolic-ref may fail if the local symref wasn’t set.
-          await execAsync(`git remote set-head origin --auto`, { cwd: targetPath, timeout: 30 * 1000 })
+          await git(['remote', 'set-head', 'origin', '--auto'], { cwd: targetPath, timeout: 30 * 1000 })
             .catch(() => { /* if this fails the next step might still succeed */ });
 
           let defaultBranch: string | null = null;
           try {
-            const headRes = await execAsync(
-              `git symbolic-ref --short refs/remotes/origin/HEAD`,
-              { cwd: targetPath, timeout: 5000 },
-            );
+            const headRes = await git(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], {
+              cwd: targetPath, timeout: 5000,
+            });
             defaultBranch = headRes.stdout.trim().replace(/^origin\//, '');
           } catch {
             // Fall back to ls-remote query against the actual remote
             try {
-              const lsRes = await execAsync(
-                `git ls-remote --symref origin HEAD`,
-                { cwd: targetPath, timeout: 30 * 1000 },
-              );
+              const lsRes = await git(['ls-remote', '--symref', 'origin', 'HEAD'], {
+                cwd: targetPath, timeout: 30 * 1000,
+              });
               const match = lsRes.stdout.match(/^ref:\s+refs\/heads\/(\S+)\s+HEAD$/m);
               if (match) defaultBranch = match[1];
             } catch { /* fall through to common-name fallback */ }
@@ -246,10 +246,9 @@ export async function cloneWithGhq(
           // Final fallback: try common default branches
           if (!defaultBranch) {
             for (const candidate of ['main', 'master']) {
-              const exists = await execAsync(
-                `git rev-parse --verify --quiet origin/${candidate}`,
-                { cwd: targetPath, timeout: 5000 },
-              ).then(() => true).catch(() => false);
+              const exists = await git(['rev-parse', '--verify', '--quiet', `origin/${candidate}`], {
+                cwd: targetPath, timeout: 5000,
+              }).then(() => true).catch(() => false);
               if (exists) { defaultBranch = candidate; break; }
             }
           }
@@ -258,8 +257,8 @@ export async function cloneWithGhq(
             throw new Error('could not determine default branch (no origin/HEAD, no main, no master)');
           }
 
-          await execAsync(`git checkout --quiet "${defaultBranch}"`, { cwd: targetPath, timeout: 10 * 1000 });
-          await execAsync(`git reset --hard --quiet "origin/${defaultBranch}"`, { cwd: targetPath, timeout: 10 * 1000 });
+          await git(['checkout', '--quiet', defaultBranch], { cwd: targetPath, timeout: 10 * 1000 });
+          await git(['reset', '--hard', '--quiet', `origin/${defaultBranch}`], { cwd: targetPath, timeout: 10 * 1000 });
           alignedToHead = true;
         } catch (error) {
           alignError = error instanceof Error ? error.message : String(error);
@@ -277,7 +276,7 @@ export async function cloneWithGhq(
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
         logWarning(`Local clone from ghq failed: ${errorMessage}`);
         // Clean up partial clone before fallback
-        try { await execAsync(`rm -rf "${targetPath}"`); } catch { /* ignore */ }
+        try { await fs.rm(targetPath, { recursive: true, force: true }); } catch { /* ignore */ }
         // Fall through to direct clone
       }
     }
@@ -285,7 +284,7 @@ export async function cloneWithGhq(
 
   // Fallback to direct git clone
   try {
-    await execAsync(`git clone "${repoUrl}" "${targetPath}"`, { timeout: CLONE_TIMEOUT_MS, maxBuffer: CLONE_MAX_BUFFER });
+    await git(['clone', repoUrl, targetPath], { timeout: CLONE_TIMEOUT_MS, maxBuffer: CLONE_MAX_BUFFER });
     return { success: true, usedGhq: false };
   } catch (error) {
     return { success: false, error: describeCloneError(error), usedGhq: false };

package/src/utils/git-operations.ts

@@ -1,4 +1,4 @@
-import { exec, execFile } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 import * as path from 'path';
 import * as fs from 'fs/promises';
@@ -10,7 +10,6 @@ import { withRetry } from './retry';
 import { createSimpleProgressBar } from './progress';
 import { getCloneUrl, CLONE_TIMEOUT_MS, CLONE_MAX_BUFFER } from './config';
 
-const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 
 const CONCURRENCY_LIMIT = 3;
@@ -96,13 +95,13 @@ async function cloneLocal(
   const targetPath = path.join(workspacePath, directoryName);
   try {
     // git clone --local creates hardlinks for .git/objects — nearly instant
-    await execAsync(`git clone --local "${sourcePath}" "${targetPath}"`, {
+    await execFileAsync('git', ['clone', '--local', sourcePath, targetPath], {
       timeout: CLONE_TIMEOUT,
       maxBuffer: CLONE_MAX_BUFFER,
     });
     // Reset the remote to point to the original repo (not the local source)
     const remoteUrl = getCloneUrl(repo);
-    await execAsync(`git remote set-url origin "${remoteUrl}"`, {
+    await execFileAsync('git', ['remote', 'set-url', 'origin', remoteUrl], {
       cwd: targetPath,
     });
     return {

package/src/utils/health-checks.ts

@@ -1,4 +1,4 @@
-import { exec } from 'child_process';
+import { exec, execFile } from 'child_process';
 import { promisify } from 'util';
 import * as fs from 'fs/promises';
 import * as path from 'path';
@@ -6,6 +6,7 @@ import { HealthCheckResult, WorkspaceMetadata } from '../types';
 import { isGitRepository, hasUncommittedChanges } from './git-status';
 
 const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 export const checkMissingRepositories = async (
   workspacePath: string,
@@ -215,7 +216,7 @@ export const checkDependencies = async (
 export const checkDiskSpace = async (workspacePath: string): Promise<HealthCheckResult> => {
   try {
     // Get disk usage for workspace
-    const { stdout } = await execAsync(`du -sh "${workspacePath}"`, { timeout: 30000 });
+    const { stdout } = await execFileAsync('du', ['-sh', workspacePath], { timeout: 30000 });
     const sizeStr = stdout.trim().split('\t')[0];
 
     // Parse size (rough check for > 10GB)

package/src/utils/logger.ts

@@ -1,5 +1,10 @@
 import { colors, colorize } from './colors';
 
+// Diagnostics (info/success/error/warn/step) go to STDERR so stdout carries only
+// a command's actual data — required for clean `--json` piping (nemus list
+// --json | jq …) and for non-TTY consumers. Use `outputJson`/stdout for data.
+const logStream = (line: string): void => console.error(line);
+
 const getTimestamp = (): string => {
   const now = new Date();
   return now.toLocaleTimeString('en-US', {
@@ -11,27 +16,27 @@ const getTimestamp = (): string => {
 };
 
 export const logInfo = (message: string): void => {
-  console.log(`${colors.gray}[${getTimestamp()}]${colors.reset} ${message}`);
+  logStream(`${colors.gray}[${getTimestamp()}]${colors.reset} ${message}`);
 };
 
 export const logSuccess = (message: string): void => {
-  console.log(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('✓', 'green')} ${message}`);
+  logStream(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('✓', 'green')} ${message}`);
 };
 
 export const logError = (message: string): void => {
-  console.log(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('✗', 'red')} ${message}`);
+  logStream(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('✗', 'red')} ${message}`);
 };
 
 export const logWarning = (message: string): void => {
-  console.log(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('⚠', 'yellow')} ${message}`);
+  logStream(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('⚠', 'yellow')} ${message}`);
 };
 
 export const logStep = (stepOrMessage: number | string, total?: number, message?: string): void => {
   if (typeof stepOrMessage === 'string') {
     // Single parameter version: just a message
-    console.log(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('▸', 'cyan')} ${stepOrMessage}`);
+    logStream(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize('▸', 'cyan')} ${stepOrMessage}`);
   } else {
     // Three parameter version: step, total, message
-    console.log(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize(`[${stepOrMessage}/${total}]`, 'cyan')} ${message}`);
+    logStream(`${colors.gray}[${getTimestamp()}]${colors.reset} ${colorize(`[${stepOrMessage}/${total}]`, 'cyan')} ${message}`);
   }
 };

package/src/utils/output.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { outputJson, outputJsonError } from './output';
+
+function captureStdout(): { calls: string[]; restore: () => void } {
+  const calls: string[] = [];
+  const spy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk: any) => {
+    calls.push(String(chunk));
+    return true;
+  });
+  return { calls, restore: () => spy.mockRestore() };
+}
+
+describe('outputJson', () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it('writes exactly one pretty JSON document + trailing newline to stdout', () => {
+    const { calls, restore } = captureStdout();
+    outputJson({ a: 1, b: ['x', 'y'] });
+    restore();
+    expect(calls).toHaveLength(1);
+    expect(calls[0].endsWith('\n')).toBe(true);
+    expect(calls[0]).toBe(JSON.stringify({ a: 1, b: ['x', 'y'] }, null, 2) + '\n');
+    expect(JSON.parse(calls[0])).toEqual({ a: 1, b: ['x', 'y'] });
+  });
+});
+
+describe('outputJsonError', () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it('emits a parseable { ok:false, error } object to stdout', () => {
+    const { calls, restore } = captureStdout();
+    outputJsonError('boom');
+    restore();
+    expect(JSON.parse(calls[0])).toEqual({ ok: false, error: 'boom' });
+  });
+});

package/src/utils/output.ts

@@ -0,0 +1,21 @@
+/**
+ * Machine-readable output helpers. The one rule: a command's DATA goes to
+ * stdout, diagnostics go to stderr (see logger.ts). In `--json` mode a command
+ * writes exactly one JSON document to stdout and nothing else, so it pipes
+ * cleanly into `jq` and is safe for scripts/CI.
+ */
+
+/** Write one pretty-printed JSON document to stdout (data channel). */
+export function outputJson(data: unknown): void {
+  process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Emit a structured error as JSON to stdout for `--json` callers, so a script
+ * parsing stdout always gets a parseable object (`{ ok: false, error }`) rather
+ * than empty stdout + a human log line on stderr. The caller still signals
+ * failure with a non-zero exit code.
+ */
+export function outputJsonError(message: string): void {
+  outputJson({ ok: false, error: message });
+}