@nemus-cli/nemus 0.2.1

package/src/utils/git-operations.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { cloneRepositories, cloneSingleRepo } from './git-operations';
+import { GitHubRepo } from '../types';
+
+// Mock child_process.exec
+const mockExecAsync = vi.fn();
+const mockExecFile = vi.fn();
+vi.mock('child_process', () => ({
+  exec: (...args: unknown[]) => {
+    const callback = args[args.length - 1] as (err: Error | null, result: { stdout: string; stderr: string }) => void;
+    const command = args[0] as string;
+    const opts = args.length === 3 ? args[1] : {};
+    // Forward to our mockExecAsync which returns a promise
+    mockExecAsync(command, opts)
+      .then((result: { stdout: string; stderr: string }) => callback(null, result))
+      .catch((err: Error) => callback(err, { stdout: '', stderr: '' }));
+  },
+  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] : {};
+    // Record the raw argv so tests can assert no-shell/argv separation.
+    mockExecFile(file, fileArgs, opts);
+    // Forward as a reconstructed command string so existing expectations match.
+    mockExecAsync([file, ...fileArgs].join(' '), opts)
+      .then((result: { stdout: string; stderr: string }) => callback(null, result))
+      .catch((err: Error) => callback(err, { stdout: '', stderr: '' }));
+  },
+}));
+
+vi.mock('fs/promises', () => ({
+  rm: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('./logger', () => ({
+  logSuccess: vi.fn(),
+  logError: vi.fn(),
+  logInfo: vi.fn(),
+  logWarning: vi.fn(),
+}));
+
+vi.mock('./colors', () => ({
+  colorize: (text: string) => text,
+}));
+
+vi.mock('./ghq-integration', () => ({
+  isGhqInstalled: vi.fn().mockResolvedValue(false),
+  cloneWithGhq: vi.fn(),
+  describeCloneError: (e: { message?: string }) => (e && e.message) || 'Unknown error',
+}));
+
+vi.mock('./retry', () => ({
+  withRetry: vi.fn(async (fn: () => Promise<unknown>) => fn()),
+}));
+
+vi.mock('./progress', () => ({
+  createSimpleProgressBar: vi.fn(() => ({
+    start: vi.fn(),
+    update: vi.fn(),
+    stop: vi.fn(),
+  })),
+}));
+
+function makeRepo(name: string, sshUrl?: string): GitHubRepo {
+  return {
+    name,
+    url: `https://github.com/org/${name}`,
+    sshUrl: sshUrl ?? `git@github.com:org/${name}.git`,
+    owner: { login: 'org' },
+    description: `${name} repo`,
+    isPrivate: false,
+  };
+}
+
+describe('cloneRepositories', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Default: all exec commands succeed
+    mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
+  });
+
+  it('clones unique repos normally', async () => {
+    const repoA = makeRepo('repo-a');
+    const repoB = makeRepo('repo-b');
+
+    const results = await cloneRepositories(
+      [
+        { repo: repoA, directoryName: 'repo-a' },
+        { repo: repoB, directoryName: 'repo-b' },
+      ],
+      '/workspace'
+    );
+
+    expect(results).toHaveLength(2);
+    expect(results.every(r => r.status === 'success')).toBe(true);
+    expect(results[0].directoryName).toBe('repo-a');
+    expect(results[1].directoryName).toBe('repo-b');
+
+    // Should have 2 git clone calls (one per unique repo), no --local calls
+    const cloneCalls = mockExecAsync.mock.calls.filter(
+      ([cmd]: [string]) => typeof cmd === 'string' && cmd.includes('git clone')
+    );
+    expect(cloneCalls).toHaveLength(2);
+    const localCalls = cloneCalls.filter(([cmd]: [string]) => cmd.includes('--local'));
+    expect(localCalls).toHaveLength(0);
+  });
+
+  it('uses --local for duplicate repos', async () => {
+    const repo = makeRepo('platform-app');
+
+    const results = await cloneRepositories(
+      [
+        { repo, directoryName: 'platform-app-1' },
+        { repo, directoryName: 'platform-app-2' },
+        { repo, directoryName: 'platform-app-3' },
+      ],
+      '/workspace'
+    );
+
+    expect(results).toHaveLength(3);
+    expect(results.every(r => r.status === 'success')).toBe(true);
+
+    // First should be a normal clone, 2nd and 3rd via --local
+    const cloneCalls = mockExecAsync.mock.calls.filter(
+      ([cmd]: [string]) => typeof cmd === 'string' && cmd.includes('git clone')
+    );
+    const normalClones = cloneCalls.filter(([cmd]: [string]) => !cmd.includes('--local'));
+    const localClones = cloneCalls.filter(([cmd]: [string]) => cmd.includes('--local'));
+
+    expect(normalClones).toHaveLength(1);
+    expect(localClones).toHaveLength(2);
+
+    // --local clones should reference the first instance's path as source
+    for (const [cmd] of localClones) {
+      expect(cmd).toContain('/workspace/platform-app-1');
+    }
+  });
+
+  it('sets correct remote origin on --local clones', async () => {
+    const repo = makeRepo('platform-app');
+
+    await cloneRepositories(
+      [
+        { repo, directoryName: 'app-1' },
+        { repo, directoryName: 'app-2' },
+      ],
+      '/workspace'
+    );
+
+    // Should have set-url calls for the --local copies
+    const setUrlCalls = mockExecAsync.mock.calls.filter(
+      ([cmd]: [string]) => typeof cmd === 'string' && cmd.includes('git remote set-url origin')
+    );
+
+    expect(setUrlCalls).toHaveLength(1);
+    expect(setUrlCalls[0][0]).toContain(repo.sshUrl);
+    expect(setUrlCalls[0][1]).toEqual(expect.objectContaining({ cwd: '/workspace/app-2' }));
+  });
+
+  it('clones via execFile with separated argv (no shell), preserving spaces in the path', async () => {
+    const repo = makeRepo('platform-app');
+    mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
+
+    // Directory name with a space would break unquoted shell interpolation.
+    const result = await cloneSingleRepo(repo, '/work space', 'dir with space', false);
+
+    expect(result.status).toBe('success');
+    const cloneCall = mockExecFile.mock.calls.find(c => c[1]?.[0] === 'clone');
+    expect(cloneCall).toBeDefined();
+    expect(cloneCall![0]).toBe('git');
+    expect(cloneCall![1]).toEqual(['clone', repo.sshUrl, '/work space/dir with space']);
+    // Argv separation means no arg is a joined shell string.
+    expect(cloneCall![1].some((a: string) => a.includes(' clone '))).toBe(false);
+  });
+
+  it('marks remaining instances as failed when primary clone fails', async () => {
+    const repo = makeRepo('broken-repo');
+
+    // Make git clone fail
+    mockExecAsync.mockRejectedValue(new Error('clone failed'));
+
+    const results = await cloneRepositories(
+      [
+        { repo, directoryName: 'broken-1' },
+        { repo, directoryName: 'broken-2' },
+        { repo, directoryName: 'broken-3' },
+      ],
+      '/workspace'
+    );
+
+    expect(results).toHaveLength(3);
+    expect(results.every(r => r.status === 'failed')).toBe(true);
+    expect(results[0].error).toBe('clone failed');
+    expect(results[1].error).toBe('Primary clone failed');
+    expect(results[2].error).toBe('Primary clone failed');
+  });
+
+  it('handles mix of unique and duplicate repos', async () => {
+    const repoA = makeRepo('repo-a');
+    const repoB = makeRepo('repo-b');
+
+    const results = await cloneRepositories(
+      [
+        { repo: repoA, directoryName: 'repo-a-1' },
+        { repo: repoA, directoryName: 'repo-a-2' },
+        { repo: repoB, directoryName: 'repo-b-1' },
+      ],
+      '/workspace'
+    );
+
+    expect(results).toHaveLength(3);
+    expect(results.every(r => r.status === 'success')).toBe(true);
+
+    const cloneCalls = mockExecAsync.mock.calls.filter(
+      ([cmd]: [string]) => typeof cmd === 'string' && cmd.includes('git clone')
+    );
+    const normalClones = cloneCalls.filter(([cmd]: [string]) => !cmd.includes('--local'));
+    const localClones = cloneCalls.filter(([cmd]: [string]) => cmd.includes('--local'));
+
+    // 2 normal clones (one per unique repo), 1 --local clone for the duplicate
+    expect(normalClones).toHaveLength(2);
+    expect(localClones).toHaveLength(1);
+    expect(localClones[0][0]).toContain('/workspace/repo-a-1');
+  });
+
+  it('handles --local clone failure independently', async () => {
+    const repo = makeRepo('platform-app');
+
+    // First clone succeeds, --local clone fails
+    mockExecAsync
+      .mockResolvedValueOnce({ stdout: '', stderr: '' }) // git clone (normal)
+      .mockRejectedValueOnce(new Error('local clone failed')); // git clone --local
+
+    const results = await cloneRepositories(
+      [
+        { repo, directoryName: 'app-1' },
+        { repo, directoryName: 'app-2' },
+      ],
+      '/workspace'
+    );
+
+    expect(results).toHaveLength(2);
+    expect(results[0].status).toBe('success');
+    expect(results[0].directoryName).toBe('app-1');
+    expect(results[1].status).toBe('failed');
+    expect(results[1].directoryName).toBe('app-2');
+    expect(results[1].error).toBe('local clone failed');
+  });
+
+  it('returns correct clonedAt timestamp on success', async () => {
+    const repo = makeRepo('repo-a');
+
+    const before = new Date().toISOString();
+    const results = await cloneRepositories(
+      [{ repo, directoryName: 'repo-a' }],
+      '/workspace'
+    );
+    const after = new Date().toISOString();
+
+    expect(results[0].clonedAt).toBeDefined();
+    expect(results[0].clonedAt! >= before).toBe(true);
+    expect(results[0].clonedAt! <= after).toBe(true);
+  });
+});

package/src/utils/git-operations.ts

@@ -0,0 +1,233 @@
+import { exec, execFile } from 'child_process';
+import { promisify } from 'util';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { GitHubRepo, CloneResult } from '../types';
+import { logSuccess, logError, logInfo, logWarning } from './logger';
+import { colorize } from './colors';
+import { cloneWithGhq, isGhqInstalled, describeCloneError } from './ghq-integration';
+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;
+const CLONE_TIMEOUT = CLONE_TIMEOUT_MS;
+
+export const cloneSingleRepo = async (
+  repo: GitHubRepo,
+  workspacePath: string,
+  directoryName: string,
+  useGhq: boolean = true,
+  silent: boolean = false
+): Promise<CloneResult> => {
+  const repoPath = path.join(workspacePath, directoryName);
+  const cloneUrl = getCloneUrl(repo);
+  const displayName = directoryName !== repo.name
+    ? `${colorize(directoryName, 'cyan')} (${repo.name})`
+    : colorize(repo.name, 'cyan');
+
+  try {
+    if (!silent) logInfo(`Cloning ${displayName}...`);
+
+    await withRetry(async () => {
+      // Clean up partial clone before retry
+      try {
+        await fs.rm(repoPath, { recursive: true, force: true });
+      } catch {
+        // Ignore cleanup errors
+      }
+
+      if (useGhq) {
+        const result = await cloneWithGhq(cloneUrl, repoPath);
+        if (!result.success) {
+          throw new Error(result.error || 'Clone failed');
+        }
+        if (!silent) {
+          if (result.usedGhq) {
+            logSuccess(`Cloned ${displayName} ${colorize('(via ghq)', 'gray')}`);
+          } else {
+            logSuccess(`Cloned ${displayName}`);
+          }
+        }
+      } else {
+        try {
+          // execFile (no shell) so repo URLs / paths with spaces or shell
+          // metacharacters can't break or inject into the command.
+          await execFileAsync('git', ['clone', cloneUrl, repoPath], {
+            timeout: CLONE_TIMEOUT,
+            maxBuffer: CLONE_MAX_BUFFER,
+          });
+        } catch (err) {
+          // execFile loses the reason on timeout/buffer kill — explain it.
+          throw new Error(describeCloneError(err, CLONE_TIMEOUT));
+        }
+        if (!silent) logSuccess(`Cloned ${displayName}`);
+      }
+    }, undefined, `Clone ${repo.name}`);
+
+    return {
+      repo,
+      directoryName,
+      status: 'success',
+      clonedAt: new Date().toISOString(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    logError(`Failed to clone ${displayName}: ${errorMessage}`);
+
+    return {
+      repo,
+      directoryName,
+      status: 'failed',
+      error: errorMessage,
+    };
+  }
+};
+
+async function cloneLocal(
+  repo: GitHubRepo,
+  sourcePath: string,
+  workspacePath: string,
+  directoryName: string
+): Promise<CloneResult> {
+  const targetPath = path.join(workspacePath, directoryName);
+  try {
+    // git clone --local creates hardlinks for .git/objects — nearly instant
+    await execAsync(`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}"`, {
+      cwd: targetPath,
+    });
+    return {
+      repo,
+      directoryName,
+      status: 'success',
+      clonedAt: new Date().toISOString(),
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    return {
+      repo,
+      directoryName,
+      status: 'failed',
+      error: errorMessage,
+    };
+  }
+}
+
+export const cloneRepositories = async (
+  repoEntries: Array<{ repo: GitHubRepo; directoryName: string }>,
+  workspacePath: string
+): Promise<CloneResult[]> => {
+  // Check if ghq is available
+  const hasGhq = await isGhqInstalled();
+
+  console.log('\n' + '='.repeat(60));
+  console.log(`Cloning ${repoEntries.length} repositories (${CONCURRENCY_LIMIT} concurrent clones)`);
+  if (hasGhq) {
+    console.log(colorize('Using ghq for efficient repository management', 'cyan'));
+  }
+  console.log('='.repeat(60) + '\n');
+
+  const bar = createSimpleProgressBar(repoEntries.length, 'Cloning');
+  bar.start(repoEntries.length, 0);
+
+  // Group entries by repo SSH URL to avoid duplicate clones
+  const repoGroups = new Map<string, Array<{ repo: GitHubRepo; directoryName: string }>>();
+  for (const entry of repoEntries) {
+    const key = entry.repo.sshUrl;
+    if (!repoGroups.has(key)) {
+      repoGroups.set(key, []);
+    }
+    repoGroups.get(key)!.push(entry);
+  }
+
+  const allResults: CloneResult[] = [];
+  let completed = 0;
+
+  // Process unique repo groups with concurrency (different repos clone in parallel)
+  const groups = Array.from(repoGroups.values());
+  for (let i = 0; i < groups.length; i += CONCURRENCY_LIMIT) {
+    const chunk = groups.slice(i, i + CONCURRENCY_LIMIT);
+    const chunkPromises = chunk.map(async (entries) => {
+      const groupResults: CloneResult[] = [];
+
+      // Clone first instance normally
+      const first = entries[0];
+      const firstResult = await cloneSingleRepo(
+        first.repo, workspacePath, first.directoryName, hasGhq, true
+      );
+      groupResults.push(firstResult);
+      completed++;
+      bar.update(completed);
+
+      // Clone remaining instances via --local from the first
+      if (firstResult.status === 'success' && entries.length > 1) {
+        const sourcePath = path.join(workspacePath, first.directoryName);
+        for (const entry of entries.slice(1)) {
+          const result = await cloneLocal(
+            entry.repo, sourcePath, workspacePath, entry.directoryName
+          );
+          groupResults.push(result);
+          completed++;
+          bar.update(completed);
+        }
+      } else if (firstResult.status === 'failed' && entries.length > 1) {
+        // Mark remaining as failed too
+        for (const entry of entries.slice(1)) {
+          groupResults.push({
+            repo: entry.repo,
+            directoryName: entry.directoryName,
+            status: 'failed',
+            error: 'Primary clone failed',
+          });
+          completed++;
+          bar.update(completed);
+        }
+      }
+
+      return groupResults;
+    });
+
+    const chunkResults = await Promise.all(chunkPromises);
+    for (const groupResults of chunkResults) {
+      allResults.push(...groupResults);
+    }
+  }
+
+  bar.stop();
+  console.log('');
+
+  return allResults;
+};
+
+export const reportCloneResults = (results: CloneResult[]): void => {
+  const successful = results.filter(r => r.status === 'success');
+  const failed = results.filter(r => r.status === 'failed');
+
+  console.log('\n' + '='.repeat(60));
+  console.log('Clone Results Summary');
+  console.log('='.repeat(60));
+  console.log(`${colorize('✓', 'green')} Successful: ${successful.length}`);
+  console.log(`${colorize('✗', 'red')} Failed: ${failed.length}`);
+  console.log('='.repeat(60));
+
+  if (failed.length > 0) {
+    console.log('\nFailed repositories:');
+    failed.forEach(result => {
+      const displayName = result.directoryName !== result.repo.name
+        ? `${result.directoryName} (${result.repo.name})`
+        : result.repo.name;
+      console.log(`  ${colorize('✗', 'red')} ${displayName}: ${result.error}`);
+    });
+  }
+
+  console.log('');
+};

package/src/utils/git-status.ts

@@ -0,0 +1,171 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as path from 'path';
+import { GitStatus } from '../types';
+
+const execAsync = promisify(exec);
+const GIT_TIMEOUT = 10000; // 10 seconds per git operation
+
+export const getGitStatus = async (repoPath: string, repoName: string): Promise<GitStatus> => {
+  try {
+    const results = await Promise.allSettled([
+      getCurrentBranch(repoPath),
+      getUncommittedChanges(repoPath),
+      getAheadBehindCounts(repoPath),
+    ]);
+
+    const branch = results[0].status === 'fulfilled' ? results[0].value : 'unknown';
+    const changes = results[1].status === 'fulfilled' ? results[1].value : { clean: false, modifiedFiles: 0, untrackedFiles: 0 };
+    const tracking = results[2].status === 'fulfilled' ? results[2].value : { ahead: 0, behind: 0, hasRemote: false };
+
+    return {
+      repo: repoName,
+      branch,
+      clean: changes.clean,
+      ahead: tracking.ahead,
+      behind: tracking.behind,
+      modifiedFiles: changes.modifiedFiles,
+      untrackedFiles: changes.untrackedFiles,
+      hasRemote: tracking.hasRemote,
+      detachedHead: branch.startsWith('HEAD detached'),
+    };
+  } catch (error) {
+    // Return error state
+    return {
+      repo: repoName,
+      branch: 'unknown',
+      clean: false,
+      ahead: 0,
+      behind: 0,
+      modifiedFiles: 0,
+      untrackedFiles: 0,
+      hasRemote: false,
+      detachedHead: false,
+    };
+  }
+};
+
+export const getCurrentBranch = async (repoPath: string): Promise<string> => {
+  try {
+    const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT,
+    });
+    const branch = stdout.trim();
+
+    // Check for detached HEAD
+    if (branch === 'HEAD') {
+      const { stdout: commitHash } = await execAsync('git rev-parse --short HEAD', {
+        cwd: repoPath,
+        timeout: GIT_TIMEOUT,
+      });
+      return `HEAD detached at ${commitHash.trim()}`;
+    }
+
+    return branch;
+  } catch (error) {
+    return 'unknown';
+  }
+};
+
+export const getUncommittedChanges = async (
+  repoPath: string
+): Promise<{ clean: boolean; modifiedFiles: number; untrackedFiles: number }> => {
+  try {
+    const { stdout } = await execAsync('git status --porcelain', {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT,
+    });
+
+    if (!stdout.trim()) {
+      return { clean: true, modifiedFiles: 0, untrackedFiles: 0 };
+    }
+
+    const lines = stdout.trim().split('\n');
+    let modifiedFiles = 0;
+    let untrackedFiles = 0;
+
+    for (const line of lines) {
+      const status = line.substring(0, 2);
+      if (status.includes('?')) {
+        untrackedFiles++;
+      } else {
+        modifiedFiles++;
+      }
+    }
+
+    return { clean: false, modifiedFiles, untrackedFiles };
+  } catch (error) {
+    return { clean: false, modifiedFiles: 0, untrackedFiles: 0 };
+  }
+};
+
+export const getAheadBehindCounts = async (
+  repoPath: string
+): Promise<{ ahead: number; behind: number; hasRemote: boolean }> => {
+  try {
+    // First check if there's a remote tracking branch
+    const { stdout: upstreamBranch } = await execAsync('git rev-parse --abbrev-ref @{upstream}', {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT,
+    });
+
+    if (!upstreamBranch.trim()) {
+      return { ahead: 0, behind: 0, hasRemote: false };
+    }
+
+    // Get ahead/behind counts
+    const { stdout } = await execAsync('git rev-list --count --left-right @{upstream}...HEAD', {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT,
+    });
+
+    const counts = stdout.trim().split('\t');
+    const behind = parseInt(counts[0], 10) || 0;
+    const ahead = parseInt(counts[1], 10) || 0;
+
+    return { ahead, behind, hasRemote: true };
+  } catch (error) {
+    // No remote tracking branch
+    return { ahead: 0, behind: 0, hasRemote: false };
+  }
+};
+
+export const getAllReposStatus = async (
+  workspacePath: string,
+  repoNames: string[],
+  concurrency: number = 3
+): Promise<GitStatus[]> => {
+  const results: GitStatus[] = [];
+
+  // Process in chunks for controlled parallelism
+  for (let i = 0; i < repoNames.length; i += concurrency) {
+    const chunk = repoNames.slice(i, i + concurrency);
+    const chunkResults = await Promise.all(
+      chunk.map(repoName => {
+        const repoPath = path.join(workspacePath, repoName);
+        return getGitStatus(repoPath, repoName);
+      })
+    );
+    results.push(...chunkResults);
+  }
+
+  return results;
+};
+
+export const hasUncommittedChanges = async (repoPath: string): Promise<boolean> => {
+  const { clean } = await getUncommittedChanges(repoPath);
+  return !clean;
+};
+
+export const isGitRepository = async (repoPath: string): Promise<boolean> => {
+  try {
+    await execAsync('git rev-parse --git-dir', {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT,
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+};