@nexical/cli 0.11.0 → 0.11.2

package/src/utils/git.ts

@@ -4,62 +4,69 @@ import { promisify } from 'node:util';
 
 const execAsync = promisify(exec);
 
-export async function clone(url: string, destination: string, options: { recursive?: boolean; depth?: number } = {}): Promise<void> {
-    const { recursive = false, depth } = options;
-    const cmd = `git clone ${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;
-    logger.debug(`Git clone: ${url} to ${destination}`);
-    await runCommand(cmd, destination);
+export async function clone(
+  url: string,
+  destination: string,
+  options: { recursive?: boolean; depth?: number } = {},
+): Promise<void> {
+  const { recursive = false, depth } = options;
+  const cmd = `git clone ${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;
+  logger.debug(`Git clone: ${url} to ${destination}`);
+  await runCommand(cmd, destination);
 }
 
 export async function getRemoteUrl(cwd: string, remote = 'origin'): Promise<string> {
-    try {
-        const { stdout } = await execAsync(`git remote get-url ${remote}`, { cwd });
-        return stdout.trim();
-    } catch (e) {
-        console.error('getRemoteUrl failed:', e);
-        return '';
-    }
+  try {
+    const { stdout } = await execAsync(`git remote get-url ${remote}`, { cwd });
+    return stdout.trim();
+  } catch (e) {
+    console.error('getRemoteUrl failed:', e);
+    return '';
+  }
 }
 
 export async function updateSubmodules(cwd: string): Promise<void> {
-    logger.debug(`Updating submodules in ${cwd}`);
-    await runCommand('git submodule foreach --recursive "git checkout main && git pull origin main"', cwd);
+  logger.debug(`Updating submodules in ${cwd}`);
+  await runCommand(
+    'git submodule foreach --recursive "git checkout main && git pull origin main"',
+    cwd,
+  );
 }
 
 export async function checkoutOrphan(branch: string, cwd: string): Promise<void> {
-    await runCommand(`git checkout --orphan ${branch}`, cwd);
+  await runCommand(`git checkout --orphan ${branch}`, cwd);
 }
 
 export async function addAll(cwd: string): Promise<void> {
-    await runCommand('git add -A', cwd);
+  await runCommand('git add -A', cwd);
 }
 
 export async function commit(message: string, cwd: string): Promise<void> {
-    // Escape quotes in message if needed, for now assuming simple messages
-    await runCommand(`git commit -m "${message}"`, cwd);
+  // Escape quotes in message if needed, for now assuming simple messages
+  await runCommand(`git commit -m "${message}"`, cwd);
 }
 
 export async function deleteBranch(branch: string, cwd: string): Promise<void> {
-    await runCommand(`git branch -D ${branch}`, cwd);
+  await runCommand(`git branch -D ${branch}`, cwd);
 }
 
 export async function renameBranch(branch: string, cwd: string): Promise<void> {
-    await runCommand(`git branch -m ${branch}`, cwd);
+  await runCommand(`git branch -m ${branch}`, cwd);
 }
 
 export async function removeRemote(remote: string, cwd: string): Promise<void> {
-    await runCommand(`git remote remove ${remote}`, cwd);
+  await runCommand(`git remote remove ${remote}`, cwd);
 }
 
 export async function renameRemote(oldName: string, newName: string, cwd: string): Promise<void> {
-    await runCommand(`git remote rename ${oldName} ${newName}`, cwd);
+  await runCommand(`git remote rename ${oldName} ${newName}`, cwd);
 }
 
 export async function branchExists(branch: string, cwd: string): Promise<boolean> {
-    try {
-        await execAsync(`git show-ref --verify --quiet refs/heads/${branch}`, { cwd });
-        return true;
-    } catch {
-        return false;
-    }
+  try {
+    await execAsync(`git show-ref --verify --quiet refs/heads/${branch}`, { cwd });
+    return true;
+  } catch {
+    return false;
+  }
 }

package/src/utils/url-resolver.ts

@@ -1,57 +1,62 @@
 /**
  * Resolves a git URL from various shorthand formats.
- * 
+ *
  * Supported formats:
  * - gh@org/repo -> https://github.com/org/repo.git
  * - gh@org/repo//path -> https://github.com/org/repo.git//path
  * - https://github.com/org/repo -> https://github.com/org/repo.git
  * - https://github.com/org/repo.git -> https://github.com/org/repo.git
- * 
+ *
  * @param url The URL string to resolve
  * @returns The fully qualified git URL with .git extension
  */
 export function resolveGitUrl(url: string): string {
-    if (!url) {
-        throw new Error('URL cannot be empty');
-    }
-
-    let resolved = url;
-
-    // Handle gh@ syntax
-    if (resolved.startsWith('gh@')) {
-        resolved = resolved.replace(/^gh@/, 'https://github.com/');
-    }
-
-    // Handle subpaths (split by //)
-    // We must be careful not to split the protocol (e.g. https://)
-    const protocolMatch = resolved.match(/^[a-z0-9]+:\/\//i);
-    let splitIndex = -1;
-
-    if (protocolMatch) {
-        splitIndex = resolved.indexOf('//', protocolMatch[0].length);
-    } else {
-        splitIndex = resolved.indexOf('//');
-    }
-
-    let repoUrl = resolved;
-    let subPath = '';
-
-    if (splitIndex !== -1) {
-        repoUrl = resolved.substring(0, splitIndex);
-        subPath = resolved.substring(splitIndex + 2);
-    }
-
-    // Ensure .git extension, but ONLY for remote URLs (not local paths)
-    const isLocal = repoUrl.startsWith('/') || repoUrl.startsWith('./') || repoUrl.startsWith('../') || repoUrl.startsWith('file:') || repoUrl.startsWith('~');
-
-    if (!isLocal && !repoUrl.endsWith('.git')) {
-        repoUrl += '.git';
-    }
-
-    // Reconstruction
-    if (subPath) {
-        return `${repoUrl}//${subPath}`;
-    }
-
-    return repoUrl;
+  if (!url) {
+    throw new Error('URL cannot be empty');
+  }
+
+  let resolved = url;
+
+  // Handle gh@ syntax
+  if (resolved.startsWith('gh@')) {
+    resolved = resolved.replace(/^gh@/, 'https://github.com/');
+  }
+
+  // Handle subpaths (split by //)
+  // We must be careful not to split the protocol (e.g. https://)
+  const protocolMatch = resolved.match(/^[a-z0-9]+:\/\//i);
+  let splitIndex = -1;
+
+  if (protocolMatch) {
+    splitIndex = resolved.indexOf('//', protocolMatch[0].length);
+  } else {
+    splitIndex = resolved.indexOf('//');
+  }
+
+  let repoUrl = resolved;
+  let subPath = '';
+
+  if (splitIndex !== -1) {
+    repoUrl = resolved.substring(0, splitIndex);
+    subPath = resolved.substring(splitIndex + 2);
+  }
+
+  // Ensure .git extension, but ONLY for remote URLs (not local paths)
+  const isLocal =
+    repoUrl.startsWith('/') ||
+    repoUrl.startsWith('./') ||
+    repoUrl.startsWith('../') ||
+    repoUrl.startsWith('file:') ||
+    repoUrl.startsWith('~');
+
+  if (!isLocal && !repoUrl.endsWith('.git')) {
+    repoUrl += '.git';
+  }
+
+  // Reconstruction
+  if (subPath) {
+    return `${repoUrl}//${subPath}`;
+  }
+
+  return repoUrl;
 }

package/test/e2e/lifecycle.e2e.test.ts

@@ -5,28 +5,33 @@ import fs from 'fs-extra';
 import { execa } from 'execa';
 
 describe('CLI Lifecycle E2E', () => {
-    let testRoot: string;
-    let starterDir: string;
-    let moduleDir: string;
-    let mockAstroDir: string;
-
-    beforeEach(async () => {
-        testRoot = await createTempDir('e2e-life-');
-
-        // 1. Setup Mock "Astro" package
-        // We create a local package that impersonates 'astro'.
-        // This avoids npm install downloading the internet.
-        mockAstroDir = path.join(testRoot, 'mock-astro');
-        await fs.ensureDir(mockAstroDir);
-        await fs.outputFile(path.join(mockAstroDir, 'package.json'), JSON.stringify({
-            name: 'astro',
-            version: '1.0.0',
-            bin: {
-                astro: './bin.js'
-            }
-        }));
-        // The mock binary acts as "npx astro"
-        await fs.outputFile(path.join(mockAstroDir, 'bin.js'), `#!/usr/bin/env node
+  let testRoot: string;
+  let starterDir: string;
+  let moduleDir: string;
+  let mockAstroDir: string;
+
+  beforeEach(async () => {
+    testRoot = await createTempDir('e2e-life-');
+
+    // 1. Setup Mock "Astro" package
+    // We create a local package that impersonates 'astro'.
+    // This avoids npm install downloading the internet.
+    mockAstroDir = path.join(testRoot, 'mock-astro');
+    await fs.ensureDir(mockAstroDir);
+    await fs.outputFile(
+      path.join(mockAstroDir, 'package.json'),
+      JSON.stringify({
+        name: 'astro',
+        version: '1.0.0',
+        bin: {
+          astro: './bin.js',
+        },
+      }),
+    );
+    // The mock binary acts as "npx astro"
+    await fs.outputFile(
+      path.join(mockAstroDir, 'bin.js'),
+      `#!/usr/bin/env node
 const fs = require('fs');
 const path = require('path');
 const args = process.argv.slice(2);
@@ -37,117 +42,120 @@ if (args[0] === 'build') {
     if (!fs.existsSync(dist)) fs.mkdirSync(dist, { recursive: true });
     fs.writeFileSync(path.join(dist, 'index.html'), '<html></html>');
 }
-`);
-        await fs.chmod(path.join(mockAstroDir, 'bin.js'), '755');
-
-        // 2. Setup Mock Starter Repo
-        starterDir = path.join(testRoot, 'starter-repo');
-        // We need a package.json that points 'astro' to our mock
-        await createMockRepo(starterDir, {
-            'package.json': JSON.stringify({
-                name: 'e2e-project',
-                version: '0.0.0',
-                dependencies: {
-                    // Use file: protocol to point to local mock
-                    'astro': `file:${mockAstroDir}`
-                },
-                scripts: {
-                    'build': 'astro build',
-                    'dev': 'astro dev',
-                    'preview': 'astro preview',
-                    'setup': 'echo setup'
-                }
-            }),
-            'README.md': '# E2E Starter',
-            'nexical.yml': 'name: e2e-test\nversion: 0.0.1', // ESSENTIAL for CLI to recognize project
-            'src/pages/index.astro': '--- ---',
-            'src/core/index.ts': '// core',
-            'src/core/package.json': JSON.stringify({
-                scripts: {
-                    'build': 'astro build',
-                    'dev': 'astro dev',
-                    'preview': 'astro preview'
-                }
-            })
-        });
-
-        // 3. Setup Mock Module Repo
-        moduleDir = path.join(testRoot, 'module-repo');
-        await createMockRepo(moduleDir, {
-            'package.json': JSON.stringify({ name: 'my-module', version: '0.1.0' }),
-            'module.yaml': 'name: my-test-module\nversion: 0.1.0', // Name matches E2E expectation
-            'index.ts': 'console.log("module")'
-        });
+`,
+    );
+    await fs.chmod(path.join(mockAstroDir, 'bin.js'), '755');
+
+    // 2. Setup Mock Starter Repo
+    starterDir = path.join(testRoot, 'starter-repo');
+    // We need a package.json that points 'astro' to our mock
+    await createMockRepo(starterDir, {
+      'package.json': JSON.stringify({
+        name: 'e2e-project',
+        version: '0.0.0',
+        dependencies: {
+          // Use file: protocol to point to local mock
+          astro: `file:${mockAstroDir}`,
+        },
+        scripts: {
+          build: 'astro build',
+          dev: 'astro dev',
+          preview: 'astro preview',
+          setup: 'echo setup',
+        },
+      }),
+      'README.md': '# E2E Starter',
+      'nexical.yml': 'name: e2e-test\nversion: 0.0.1', // ESSENTIAL for CLI to recognize project
+      'src/pages/index.astro': '--- ---',
+      'src/core/index.ts': '// core',
+      'src/core/package.json': JSON.stringify({
+        scripts: {
+          build: 'astro build',
+          dev: 'astro dev',
+          preview: 'astro preview',
+        },
+      }),
     });
 
-    afterAll(async () => {
-        if (testRoot) await fs.remove(testRoot);
+    // 3. Setup Mock Module Repo
+    moduleDir = path.join(testRoot, 'module-repo');
+    await createMockRepo(moduleDir, {
+      'package.json': JSON.stringify({ name: 'my-module', version: '0.1.0' }),
+      'module.yaml': 'name: my-test-module\nversion: 0.1.0', // Name matches E2E expectation
+      'index.ts': 'console.log("module")',
+    });
+  });
+
+  afterAll(async () => {
+    if (testRoot) await fs.remove(testRoot);
+  });
+
+  it('should complete a full project lifecycle', async () => {
+    const projectDir = path.join(testRoot, 'my-project');
+
+    const env = {
+      // Essential for git inside init/module commands
+      GIT_AUTHOR_NAME: 'Test User',
+      GIT_AUTHOR_EMAIL: 'test@example.com',
+      GIT_COMMITTER_NAME: 'Test User',
+      GIT_COMMITTER_EMAIL: 'test@example.com',
+      GIT_ALLOW_PROTOCOL: 'file',
+      // DEBUG: 'true' - Removed to reduce noise
+    };
+
+    // --- STEP 1: INIT ---
+    // Run: nexical init my-project --repo <starter>
+    const _initResult = await runCLI(['init', 'my-project', '--repo', starterDir], testRoot, {
+      env,
     });
 
-    it('should complete a full project lifecycle', async () => {
-        const projectDir = path.join(testRoot, 'my-project');
-
-        const env = {
-            // Essential for git inside init/module commands
-            GIT_AUTHOR_NAME: 'Test User',
-            GIT_AUTHOR_EMAIL: 'test@example.com',
-            GIT_COMMITTER_NAME: 'Test User',
-            GIT_COMMITTER_EMAIL: 'test@example.com',
-            GIT_ALLOW_PROTOCOL: 'file'
-            // DEBUG: 'true' - Removed to reduce noise
-        };
-
-        // --- STEP 1: INIT ---
-        // Run: nexical init my-project --repo <starter>
-        const initResult = await runCLI([
-            'init',
-            'my-project',
-            '--repo', starterDir
-        ], testRoot, { env });
-
-        // 4. Check git initialization (preserved history)
-        const { stdout: log } = await execa('git', ['log', '--oneline'], { cwd: projectDir });
-        const lines = log.split('\n').filter(Boolean);
-        expect(lines.length).toBeGreaterThanOrEqual(2);
-        expect(lines[0]).toContain('Initial site commit');
-
-        // --- STEP 2: MODULE ADD ---
-        // Run: nexical module add <module>
-        const modResult = await runCLI([
-            'module',
-            'add',
-            moduleDir,
-            'my-test-module' // Explicit name
-        ], projectDir, { env });
-
-        if (modResult.exitCode !== 0) {
-            console.error('Module Add Failed:', modResult.stderr || modResult.stdout);
-        }
-        expect(modResult.exitCode).toBe(0);
-        expect(fs.existsSync(path.join(projectDir, 'modules/my-test-module'))).toBe(true);
-
-        // --- STEP 3: BUILD ---
-        // Run: nexical run build
-        // Should trigger our mock astro binary
-        const buildResult = await runCLI(['run', 'build'], projectDir, { env });
-
-        if (buildResult.exitCode !== 0) {
-            console.log(buildResult.stderr || buildResult.stdout);
-        }
-
-        expect(buildResult.exitCode).toBe(0);
-        expect(buildResult.stdout).toContain('MOCK_ASTRO_EXECUTED build');
-
-        // --- STEP 4: PREVIEW ---
-        // Run: nexical run preview
-        const previewResult = await runCLI(['run', 'preview'], projectDir, { env });
-
-        expect(previewResult.exitCode).toBe(0);
-        expect(previewResult.stdout).toContain('MOCK_ASTRO_EXECUTED preview');
-
-        // --- STEP 5: CLEAN ---
-        // Clean is now handled by manual file operations or external scripts,
-        // it's no longer a top-level command.
-
-    }, 120000); // Long timeout for full chain
+    // 4. Check git initialization (preserved history)
+    const { stdout: log } = await execa('git', ['log', '--oneline'], { cwd: projectDir });
+    const lines = log.split('\n').filter(Boolean);
+    expect(lines.length).toBeGreaterThanOrEqual(2);
+    expect(lines[0]).toContain('Initial site commit');
+
+    // --- STEP 2: MODULE ADD ---
+    // Run: nexical module add <module>
+    const modResult = await runCLI(
+      [
+        'module',
+        'add',
+        moduleDir,
+        'my-test-module', // Explicit name
+      ],
+      projectDir,
+      { env },
+    );
+
+    if (modResult.exitCode !== 0) {
+      console.error('Module Add Failed:', modResult.stderr || modResult.stdout);
+    }
+    expect(modResult.exitCode).toBe(0);
+    expect(fs.existsSync(path.join(projectDir, 'modules/my-test-module'))).toBe(true);
+
+    // --- STEP 3: BUILD ---
+    // Run: nexical run build
+    // Should trigger our mock astro binary
+    const buildResult = await runCLI(['run', 'build'], projectDir, { env });
+
+    if (buildResult.exitCode !== 0) {
+      // eslint-disable-next-line no-console
+      console.log(buildResult.stderr || buildResult.stdout);
+    }
+
+    expect(buildResult.exitCode).toBe(0);
+    expect(buildResult.stdout).toContain('MOCK_ASTRO_EXECUTED build');
+
+    // --- STEP 4: PREVIEW ---
+    // Run: nexical run preview
+    const previewResult = await runCLI(['run', 'preview'], projectDir, { env });
+
+    expect(previewResult.exitCode).toBe(0);
+    expect(previewResult.stdout).toContain('MOCK_ASTRO_EXECUTED preview');
+
+    // --- STEP 5: CLEAN ---
+    // Clean is now handled by manual file operations or external scripts,
+    // it's no longer a top-level command.
+  }, 120000); // Long timeout for full chain
 });

package/test/integration/commands/init.integration.test.ts

@@ -1,85 +1,85 @@
 import { CLI } from '@nexical/cli-core';
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
 import InitCommand from '../../../src/commands/init.js';
-import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
+import { createTempDir, createMockRepo } from '../../utils/integration-helpers.js';
 import path from 'node:path';
 import fs from 'fs-extra';
 import { execa } from 'execa';
 
 describe('InitCommand Integration', () => {
-    let tempDir: string;
-    let starterRepoDir: string;
+  let tempDir: string;
+  let starterRepoDir: string;
 
-    beforeEach(async () => {
-        tempDir = await createTempDir('init-integration-');
-        const starterDir = await createTempDir('starter-repo-');
+  beforeEach(async () => {
+    tempDir = await createTempDir('init-integration-');
+    const starterDir = await createTempDir('starter-repo-');
 
-        // precise setup of a starter repo
-        starterRepoDir = await createMockRepo(starterDir, {
-            'package.json': JSON.stringify({
-                name: 'nexical-starter',
-                version: '0.0.0',
-                scripts: {
-                    setup: 'echo setup'
-                },
-                dependencies: {
-                    'is-odd': '3.0.1'
-                }
-            }),
-            'README.md': '# Starter Template'
-        });
-
-        // Set Git Identity for the test process so InitCommand's commit works in CI
-        process.env.GIT_AUTHOR_NAME = 'Test User';
-        process.env.GIT_AUTHOR_EMAIL = 'test@example.com';
-        process.env.GIT_COMMITTER_NAME = 'Test User';
-        process.env.GIT_COMMITTER_EMAIL = 'test@example.com';
-        // Allow file protocol for local cloning in CI
-        process.env.GIT_ALLOW_PROTOCOL = 'file';
+    // precise setup of a starter repo
+    starterRepoDir = await createMockRepo(starterDir, {
+      'package.json': JSON.stringify({
+        name: 'nexical-starter',
+        version: '0.0.0',
+        scripts: {
+          setup: 'echo setup',
+        },
+        dependencies: {
+          'is-odd': '3.0.1',
+        },
+      }),
+      'README.md': '# Starter Template',
     });
 
-    afterAll(async () => {
-        // await cleanupTestRoot(); // conflicting with parallel tests
-        if (tempDir) await fs.remove(tempDir);
-    });
+    // Set Git Identity for the test process so InitCommand's commit works in CI
+    process.env.GIT_AUTHOR_NAME = 'Test User';
+    process.env.GIT_AUTHOR_EMAIL = 'test@example.com';
+    process.env.GIT_COMMITTER_NAME = 'Test User';
+    process.env.GIT_COMMITTER_EMAIL = 'test@example.com';
+    // Allow file protocol for local cloning in CI
+    process.env.GIT_ALLOW_PROTOCOL = 'file';
+  });
 
-    it('should initialize a new project from a local git repo', async () => {
-        const targetProjectName = 'my-new-project';
-        const targetPath = path.join(tempDir, targetProjectName);
-        const cli = new CLI({ commandName: 'nexical' });
+  afterAll(async () => {
+    // await cleanupTestRoot(); // conflicting with parallel tests
+    if (tempDir) await fs.remove(tempDir);
+  });
 
-        const command = new InitCommand(cli);
+  it('should initialize a new project from a local git repo', async () => {
+    const targetProjectName = 'my-new-project';
+    const targetPath = path.join(tempDir, targetProjectName);
+    const cli = new CLI({ commandName: 'nexical' });
 
-        // Capture stdout/stderr? InitCommand uses consola.
-        // For integration, we care about the FS side effects.
+    const command = new InitCommand(cli);
 
-        await command.run({
-            directory: targetPath,
-            repo: starterRepoDir // Passing local path as repo URL
-        });
+    // Capture stdout/stderr? InitCommand uses consola.
+    // For integration, we care about the FS side effects.
+
+    await command.run({
+      directory: targetPath,
+      repo: starterRepoDir, // Passing local path as repo URL
+    });
 
-        // 1. Check directory exists
-        expect(fs.existsSync(targetPath)).toBe(true);
+    // 1. Check directory exists
+    expect(fs.existsSync(targetPath)).toBe(true);
 
-        // 2. Check files cloned
-        expect(fs.existsSync(path.join(targetPath, 'package.json'))).toBe(true);
-        expect(fs.existsSync(path.join(targetPath, 'README.md'))).toBe(true);
+    // 2. Check files cloned
+    expect(fs.existsSync(path.join(targetPath, 'package.json'))).toBe(true);
+    expect(fs.existsSync(path.join(targetPath, 'README.md'))).toBe(true);
 
-        // 3. Check git initialization
-        expect(fs.existsSync(path.join(targetPath, '.git'))).toBe(true);
+    // 3. Check git initialization
+    expect(fs.existsSync(path.join(targetPath, '.git'))).toBe(true);
 
-        // 4. Check git initialization (history should be preserved + one new commit)
-        const { stdout: log } = await execa('git', ['log', '--oneline'], { cwd: targetPath });
-        const lines = log.split('\n').filter(Boolean);
-        expect(lines.length).toBe(2); // Should have "Initial site commit" and "Initial commit"
-        expect(lines[0]).toContain('Initial site commit');
-        expect(lines[1]).toContain('Initial commit');
+    // 4. Check git initialization (history should be preserved + one new commit)
+    const { stdout: log } = await execa('git', ['log', '--oneline'], { cwd: targetPath });
+    const lines = log.split('\n').filter(Boolean);
+    expect(lines.length).toBe(2); // Should have "Initial site commit" and "Initial commit"
+    expect(lines[0]).toContain('Initial site commit');
+    expect(lines[1]).toContain('Initial commit');
 
-        // 5. Check dependencies (optional, but command tries to install them)
-        // Since we are mocking the repo, it doesn't have a real lockfile or valid deps,
-        // so `npm install` might have failed or done nothing.
-        // However, `InitCommand` runs `npm install`. If that fails, the command throws/exits.
-        // We provided a minimal package.json so it should succeed.
-        expect(fs.existsSync(path.join(targetPath, 'node_modules'))).toBe(true);
-    }, 60000); // Increase timeout for real git/npm ops
+    // 5. Check dependencies (optional, but command tries to install them)
+    // Since we are mocking the repo, it doesn't have a real lockfile or valid deps,
+    // so `npm install` might have failed or done nothing.
+    // However, `InitCommand` runs `npm install`. If that fails, the command throws/exits.
+    // We provided a minimal package.json so it should succeed.
+    expect(fs.existsSync(path.join(targetPath, 'node_modules'))).toBe(true);
+  }, 60000); // Increase timeout for real git/npm ops
 });