@nexical/cli 0.11.0 → 0.11.1

package/test/unit/utils/git.test.ts

@@ -1,152 +1,170 @@
 import { runCommand } from '@nexical/cli-core';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as git from '../../../src/utils/git.js';
 
 const mocks = vi.hoisted(() => ({
-    exec: vi.fn(),
+  exec: vi.fn(),
 }));
 
 vi.mock('@nexical/cli-core', async (importOriginal) => {
-    const mod = await importOriginal<typeof import('@nexical/cli-core')>();
-    return {
-        ...mod,
-        runCommand: vi.fn(),
-        logger: { code: vi.fn(), debug: vi.fn() }
-    }
+  const mod = await importOriginal<typeof import('@nexical/cli-core')>();
+  return {
+    ...mod,
+    runCommand: vi.fn(),
+    logger: { code: vi.fn(), debug: vi.fn() },
+  };
 });
 
 vi.mock('node:child_process', () => ({
-    exec: mocks.exec,
+  exec: mocks.exec,
 }));
 
 vi.mock('node:util', async () => {
-    const actual = await vi.importActual<any>('node:util');
-    return {
-        ...actual,
-        promisify: (fn: Function) => {
-            return (...args: any[]) => new Promise((resolve, reject) => {
-                fn(...args, (err: Error | null, ...values: any[]) => {
-                    if (err) return reject(err);
-                    // Handle exec-like signature (stdout, stderr) -> { stdout, stderr }
-                    // Simple heuristic: if values.length > 1, assume explicit mapping needed?
-                    // Or just hardcode for our known usage (exec).
-                    if (values.length >= 2) {
-                        resolve({ stdout: values[0], stderr: values[1] });
-                    } else {
-                        resolve(values[0]);
-                    }
-                });
-            });
-        }
-    };
+  const actual = await vi.importActual<typeof import('node:util')>('node:util');
+  return {
+    ...actual,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    promisify: (fn: Function) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return (...args: any[]) =>
+        new Promise((resolve, reject) => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          fn(...args, (err: Error | null, ...values: any[]) => {
+            if (err) return reject(err);
+            // Handle exec-like signature (stdout, stderr) -> { stdout, stderr }
+            // Simple heuristic: if values.length > 1, assume explicit mapping needed?
+            // Or just hardcode for our known usage (exec).
+            if (values.length >= 2) {
+              resolve({ stdout: values[0], stderr: values[1] });
+            } else {
+              resolve(values[0]);
+            }
+          });
+        });
+    },
+  };
 });
 
 describe('git utils', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it('should clone repository', async () => {
-        await git.clone('http://repo.git', 'dest', { recursive: true });
-        expect(runCommand).toHaveBeenCalledWith(
-            'git clone --recursive http://repo.git .',
-            'dest'
-        );
-    });
-
-    it('should clone repository with depth', async () => {
-        await git.clone('http://repo.git', 'dest', { depth: 1 });
-        expect(runCommand).toHaveBeenCalledWith(
-            'git clone --depth 1 http://repo.git .',
-            'dest'
-        );
-    });
-
-    it('should update submodules', async () => {
-        await git.updateSubmodules('dest');
-        expect(runCommand).toHaveBeenCalledWith(
-            'git submodule foreach --recursive "git checkout main && git pull origin main"',
-            'dest'
-        );
-    });
-
-    it('should checkout orphan branch', async () => {
-        await git.checkoutOrphan('branch', 'dest');
-        expect(runCommand).toHaveBeenCalledWith('git checkout --orphan branch', 'dest');
-    });
-
-    it('should get remote url', async () => {
-        // Mock exec to call the callback with success
-        mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
-            if (typeof options === 'function') {
-                callback = options;
-                options = {};
-            }
-            // callback(error, stdout, stderr)
-            callback(null, 'https://github.com/origin.git\n', '');
-            return {} as any; // exec returns a ChildProcess
-        }) as any));
-
-        const url = await git.getRemoteUrl('cwd');
-        expect(url).toBe('https://github.com/origin.git');
-        expect(mocks.exec).toHaveBeenCalledWith('git remote get-url origin', { cwd: 'cwd' }, expect.any(Function));
-    });
-
-    it('should return empty string on getRemoteUrl failure', async () => {
-        // Mock exec to call the callback with error
-        mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
-            if (typeof options === 'function') callback = options;
-            callback(new Error('fail'), '', '');
-            return {} as any;
-        }) as any));
-
-        const url = await git.getRemoteUrl('cwd');
-        expect(url).toBe('');
-    });
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should clone repository', async () => {
+    await git.clone('http://repo.git', 'dest', { recursive: true });
+    expect(runCommand).toHaveBeenCalledWith('git clone --recursive http://repo.git .', 'dest');
+  });
+
+  it('should clone repository with depth', async () => {
+    await git.clone('http://repo.git', 'dest', { depth: 1 });
+    expect(runCommand).toHaveBeenCalledWith('git clone --depth 1 http://repo.git .', 'dest');
+  });
+
+  it('should update submodules', async () => {
+    await git.updateSubmodules('dest');
+    expect(runCommand).toHaveBeenCalledWith(
+      'git submodule foreach --recursive "git checkout main && git pull origin main"',
+      'dest',
+    );
+  });
+
+  it('should checkout orphan branch', async () => {
+    await git.checkoutOrphan('branch', 'dest');
+    expect(runCommand).toHaveBeenCalledWith('git checkout --orphan branch', 'dest');
+  });
+
+  it('should get remote url', async () => {
+    // Mock exec to call the callback with success
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mocks.exec.mockImplementation(((cmd: string, options: any, callback: any) => {
+      if (typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
+      // callback(error, stdout, stderr)
+      callback(null, 'https://github.com/origin.git\n', '');
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return {} as any; // exec returns a ChildProcess
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }) as any);
+
+    const url = await git.getRemoteUrl('cwd');
+    expect(url).toBe('https://github.com/origin.git');
+    expect(mocks.exec).toHaveBeenCalledWith(
+      'git remote get-url origin',
+      { cwd: 'cwd' },
+      expect.any(Function),
+    );
+  });
+
+  it('should return empty string on getRemoteUrl failure', async () => {
+    // Mock exec to call the callback with error
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mocks.exec.mockImplementation(((cmd: string, options: any, callback: any) => {
+      if (typeof options === 'function') callback = options;
+      callback(new Error('fail'), '', '');
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return {} as any;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }) as any);
+
+    const url = await git.getRemoteUrl('cwd');
+    expect(url).toBe('');
+  });
 });
 
 it('should add all files', async () => {
-    await git.addAll('cwd');
-    expect(runCommand).toHaveBeenCalledWith('git add -A', 'cwd');
+  await git.addAll('cwd');
+  expect(runCommand).toHaveBeenCalledWith('git add -A', 'cwd');
 });
 
 it('should commit', async () => {
-    await git.commit('msg', 'cwd');
-    expect(runCommand).toHaveBeenCalledWith('git commit -m "msg"', 'cwd');
+  await git.commit('msg', 'cwd');
+  expect(runCommand).toHaveBeenCalledWith('git commit -m "msg"', 'cwd');
 });
 
 it('should delete branch', async () => {
-    await git.deleteBranch('branch', 'cwd');
-    expect(runCommand).toHaveBeenCalledWith('git branch -D branch', 'cwd');
+  await git.deleteBranch('branch', 'cwd');
+  expect(runCommand).toHaveBeenCalledWith('git branch -D branch', 'cwd');
 });
 
 it('should rename branch', async () => {
-    await git.renameBranch('branch', 'cwd');
-    expect(runCommand).toHaveBeenCalledWith('git branch -m branch', 'cwd');
+  await git.renameBranch('branch', 'cwd');
+  expect(runCommand).toHaveBeenCalledWith('git branch -m branch', 'cwd');
 });
 
 it('should remove remote', async () => {
-    await git.removeRemote('origin', 'cwd');
-    expect(runCommand).toHaveBeenCalledWith('git remote remove origin', 'cwd');
+  await git.removeRemote('origin', 'cwd');
+  expect(runCommand).toHaveBeenCalledWith('git remote remove origin', 'cwd');
 });
 
 it('should check if branch exists', async () => {
-    // Mock success
-    mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
-        if (typeof options === 'function') callback = options;
-        callback(null, '', '');
-        return {} as any;
-    }) as any));
-
-    expect(await git.branchExists('branch', 'cwd')).toBe(true);
-    expect(mocks.exec).toHaveBeenCalledWith('git show-ref --verify --quiet refs/heads/branch', { cwd: 'cwd' }, expect.any(Function));
-
-    // Mock failure
-    mocks.exec.mockImplementation((((cmd: string, options: any, callback: any) => {
-        if (typeof options === 'function') callback = options;
-        callback(new Error('fail'), '', '');
-        return {} as any;
-    }) as any));
-
-    expect(await git.branchExists('branch', 'cwd')).toBe(false);
+  // Mock success
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mocks.exec.mockImplementation(((cmd: string, options: any, callback: any) => {
+    if (typeof options === 'function') callback = options;
+    callback(null, '', '');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }) as any);
+
+  expect(await git.branchExists('branch', 'cwd')).toBe(true);
+  expect(mocks.exec).toHaveBeenCalledWith(
+    'git show-ref --verify --quiet refs/heads/branch',
+    { cwd: 'cwd' },
+    expect.any(Function),
+  );
+
+  // Mock failure
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mocks.exec.mockImplementation(((cmd: string, options: any, callback: any) => {
+    if (typeof options === 'function') callback = options;
+    callback(new Error('fail'), '', '');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }) as any);
+
+  expect(await git.branchExists('branch', 'cwd')).toBe(false);
 });

package/test/unit/utils/integration-helpers.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as helpers from '../../utils/integration-helpers.js';
 import fs from 'fs-extra';
 import { execa } from 'execa';
@@ -8,65 +8,75 @@ vi.mock('fs-extra');
 vi.mock('execa');
 
 describe('Integration Helpers Unit', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
 
-    it('runCLI should execute node with correct arguments', async () => {
-        vi.mocked(execa).mockResolvedValue({ exitCode: 0 } as any);
-        const args = ['init', 'my-project'];
-        const cwd = '/test/cwd';
-        const env = { FOO: 'bar' };
+  it('runCLI should execute node with correct arguments', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(execa).mockResolvedValue({ exitCode: 0 } as any);
+    const args = ['init', 'my-project'];
+    const cwd = '/test/cwd';
+    const env = { FOO: 'bar' };
 
-        await helpers.runCLI(args, cwd, { env });
+    await helpers.runCLI(args, cwd, { env });
 
-        expect(execa).toHaveBeenCalledWith(
-            'node',
-            expect.arrayContaining([expect.stringContaining('dist/index.js'), ...args]),
-            expect.objectContaining({
-                cwd,
-                env: expect.objectContaining({ FOO: 'bar' }),
-                reject: false
-            })
-        );
-    });
+    expect(execa).toHaveBeenCalledWith(
+      'node',
+      expect.arrayContaining([expect.stringContaining('dist/index.js'), ...args]),
+      expect.objectContaining({
+        cwd,
+        env: expect.objectContaining({ FOO: 'bar' }),
+        reject: false,
+      }),
+    );
+  });
 
-    it('createTempDir should create directory and return path', async () => {
-        vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
+  it('createTempDir should create directory and return path', async () => {
+    vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
 
-        const dir = await helpers.createTempDir('test-prefix-');
+    const dir = await helpers.createTempDir('test-prefix-');
 
-        expect(dir).toContain('test-prefix-');
-        expect(fs.ensureDir).toHaveBeenCalledWith(dir);
-    });
+    expect(dir).toContain('test-prefix-');
+    expect(fs.ensureDir).toHaveBeenCalledWith(dir);
+  });
 
-    it('cleanupTestRoot should remove test root directory', async () => {
-        vi.mocked(fs.remove).mockResolvedValue(undefined);
+  it('cleanupTestRoot should remove test root directory', async () => {
+    vi.mocked(fs.remove).mockResolvedValue(undefined);
 
-        await helpers.cleanupTestRoot();
+    await helpers.cleanupTestRoot();
 
-        expect(fs.remove).toHaveBeenCalledWith(expect.stringContaining('.test-tmp'));
-    });
+    expect(fs.remove).toHaveBeenCalledWith(expect.stringContaining('.test-tmp'));
+  });
 
-    it('createMockRepo should initialize git repo and commit files', async () => {
-        vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
-        vi.mocked(fs.outputFile).mockResolvedValue(undefined);
-        vi.mocked(execa).mockResolvedValue({} as any);
+  it('createMockRepo should initialize git repo and commit files', async () => {
+    vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
+    vi.mocked(fs.outputFile).mockResolvedValue(undefined);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(execa).mockResolvedValue({} as any);
 
-        const dir = '/test/repo';
-        const files = {
-            'package.json': '{}',
-            'README.md': '# Test'
-        };
+    const dir = '/test/repo';
+    const files = {
+      'package.json': '{}',
+      'README.md': '# Test',
+    };
 
-        await helpers.createMockRepo(dir, files);
+    await helpers.createMockRepo(dir, files);
 
-        expect(fs.ensureDir).toHaveBeenCalledWith(dir);
-        expect(execa).toHaveBeenCalledWith('git', ['init'], expect.objectContaining({ cwd: dir }));
-        expect(execa).toHaveBeenCalledWith('git', ['config', 'user.email', 'test@test.com'], expect.objectContaining({ cwd: dir }));
-        expect(fs.outputFile).toHaveBeenCalledWith(path.join(dir, 'package.json'), '{}');
-        expect(fs.outputFile).toHaveBeenCalledWith(path.join(dir, 'README.md'), '# Test');
-        expect(execa).toHaveBeenCalledWith('git', ['add', '.'], expect.objectContaining({ cwd: dir }));
-        expect(execa).toHaveBeenCalledWith('git', ['commit', '-m', 'Initial commit'], expect.objectContaining({ cwd: dir }));
-    });
+    expect(fs.ensureDir).toHaveBeenCalledWith(dir);
+    expect(execa).toHaveBeenCalledWith('git', ['init'], expect.objectContaining({ cwd: dir }));
+    expect(execa).toHaveBeenCalledWith(
+      'git',
+      ['config', 'user.email', 'test@test.com'],
+      expect.objectContaining({ cwd: dir }),
+    );
+    expect(fs.outputFile).toHaveBeenCalledWith(path.join(dir, 'package.json'), '{}');
+    expect(fs.outputFile).toHaveBeenCalledWith(path.join(dir, 'README.md'), '# Test');
+    expect(execa).toHaveBeenCalledWith('git', ['add', '.'], expect.objectContaining({ cwd: dir }));
+    expect(execa).toHaveBeenCalledWith(
+      'git',
+      ['commit', '-m', 'Initial commit'],
+      expect.objectContaining({ cwd: dir }),
+    );
+  });
 });

package/test/unit/utils/url-resolver.test.ts

@@ -2,38 +2,50 @@ import { describe, it, expect } from 'vitest';
 import { resolveGitUrl } from '../../../src/utils/url-resolver';
 
 describe('resolveGitUrl', () => {
-    it('should expand gh@ shorthand correctly', () => {
-        expect(resolveGitUrl('gh@nexical-cms/starter')).toBe('https://github.com/nexical-cms/starter.git');
-    });
-
-    it('should expand gh@ shorthand with subpath correctly', () => {
-        expect(resolveGitUrl('gh@nexical-cms/starter//path/to/module')).toBe('https://github.com/nexical-cms/starter.git//path/to/module');
-    });
-
-    it('should add .git extension to standard URLs if missing', () => {
-        expect(resolveGitUrl('https://github.com/nexical-cms/starter')).toBe('https://github.com/nexical-cms/starter.git');
-    });
-
-    it('should preserve .git extension if already present', () => {
-        expect(resolveGitUrl('https://github.com/nexical-cms/starter.git')).toBe('https://github.com/nexical-cms/starter.git');
-    });
-
-    it('should handle standard URLs with subpath correctly', () => {
-        expect(resolveGitUrl('https://github.com/nexical-cms/starter//path/to/dir')).toBe('https://github.com/nexical-cms/starter.git//path/to/dir');
-    });
-
-    it('should handle standard URLs with .git and subpath correctly', () => {
-        expect(resolveGitUrl('https://github.com/nexical-cms/starter.git//path/to/dir')).toBe('https://github.com/nexical-cms/starter.git//path/to/dir');
-    });
-
-    it('should throw error for empty url', () => {
-        expect(() => resolveGitUrl('')).toThrow('URL cannot be empty');
-    });
-
-    it('should not append .git to local paths', () => {
-        expect(resolveGitUrl('/tmp/local/repo')).toBe('/tmp/local/repo');
-        expect(resolveGitUrl('./local/repo')).toBe('./local/repo');
-        expect(resolveGitUrl('../local/repo')).toBe('../local/repo');
-        expect(resolveGitUrl('file:///tmp/repo')).toBe('file:///tmp/repo');
-    });
+  it('should expand gh@ shorthand correctly', () => {
+    expect(resolveGitUrl('gh@nexical-cms/starter')).toBe(
+      'https://github.com/nexical-cms/starter.git',
+    );
+  });
+
+  it('should expand gh@ shorthand with subpath correctly', () => {
+    expect(resolveGitUrl('gh@nexical-cms/starter//path/to/module')).toBe(
+      'https://github.com/nexical-cms/starter.git//path/to/module',
+    );
+  });
+
+  it('should add .git extension to standard URLs if missing', () => {
+    expect(resolveGitUrl('https://github.com/nexical-cms/starter')).toBe(
+      'https://github.com/nexical-cms/starter.git',
+    );
+  });
+
+  it('should preserve .git extension if already present', () => {
+    expect(resolveGitUrl('https://github.com/nexical-cms/starter.git')).toBe(
+      'https://github.com/nexical-cms/starter.git',
+    );
+  });
+
+  it('should handle standard URLs with subpath correctly', () => {
+    expect(resolveGitUrl('https://github.com/nexical-cms/starter//path/to/dir')).toBe(
+      'https://github.com/nexical-cms/starter.git//path/to/dir',
+    );
+  });
+
+  it('should handle standard URLs with .git and subpath correctly', () => {
+    expect(resolveGitUrl('https://github.com/nexical-cms/starter.git//path/to/dir')).toBe(
+      'https://github.com/nexical-cms/starter.git//path/to/dir',
+    );
+  });
+
+  it('should throw error for empty url', () => {
+    expect(() => resolveGitUrl('')).toThrow('URL cannot be empty');
+  });
+
+  it('should not append .git to local paths', () => {
+    expect(resolveGitUrl('/tmp/local/repo')).toBe('/tmp/local/repo');
+    expect(resolveGitUrl('./local/repo')).toBe('./local/repo');
+    expect(resolveGitUrl('../local/repo')).toBe('../local/repo');
+    expect(resolveGitUrl('file:///tmp/repo')).toBe('file:///tmp/repo');
+  });
 });

package/test/utils/integration-helpers.ts

@@ -11,16 +11,20 @@ export const CLI_BIN = path.resolve(__dirname, '../../dist/index.js');
 /**
  * Runs the CLI command against the compiled binary (E2E style)
  */
-export async function runCLI(args: string[], cwd: string, options: any = {}) {
-    return execa('node', [CLI_BIN, ...args], {
-        cwd,
-        ...options,
-        env: {
-            ...process.env,
-            ...options.env
-        },
-        reject: false // Allow checking exit code in tests
-    });
+export async function runCLI(
+  args: string[],
+  cwd: string,
+  options: { env?: NodeJS.ProcessEnv; [key: string]: unknown } = {},
+) {
+  return execa('node', [CLI_BIN, ...args], {
+    cwd,
+    ...options,
+    env: {
+      ...process.env,
+      ...options.env,
+    },
+    reject: false, // Allow checking exit code in tests
+  });
 }
 
 /**
@@ -28,39 +32,42 @@ export async function runCLI(args: string[], cwd: string, options: any = {}) {
  * @returns The absolute path to the temporary directory.
  */
 export async function createTempDir(prefix = 'test-'): Promise<string> {
-    const dir = path.join(TEST_ROOT, `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    await fs.ensureDir(dir);
-    return dir;
+  const dir = path.join(TEST_ROOT, `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  await fs.ensureDir(dir);
+  return dir;
 }
 
 /**
  * Cleans up the temporary test root.
  */
 export async function cleanupTestRoot(): Promise<void> {
-    await fs.remove(TEST_ROOT);
+  await fs.remove(TEST_ROOT);
 }
 
 /**
  * Creates a mock git repository at the specified path.
  * This is useful for testing commands that clone from a remote.
  */
-export async function createMockRepo(dir: string, initialFiles: Record<string, string> = {}): Promise<string> {
-    await fs.ensureDir(dir);
+export async function createMockRepo(
+  dir: string,
+  initialFiles: Record<string, string> = {},
+): Promise<string> {
+  await fs.ensureDir(dir);
 
-    // Initialize bare repo? No, usually we want a regular repo then commit, 
-    // but if we want to clone FROM it locally, it acts as a remote.
-    // Let's make it a regular repo.
-    await execa('git', ['init'], { cwd: dir });
-    await execa('git', ['config', 'user.email', 'test@test.com'], { cwd: dir });
-    await execa('git', ['config', 'user.name', 'Test User'], { cwd: dir });
+  // Initialize bare repo? No, usually we want a regular repo then commit,
+  // but if we want to clone FROM it locally, it acts as a remote.
+  // Let's make it a regular repo.
+  await execa('git', ['init'], { cwd: dir });
+  await execa('git', ['config', 'user.email', 'test@test.com'], { cwd: dir });
+  await execa('git', ['config', 'user.name', 'Test User'], { cwd: dir });
 
-    // Write initial files
-    for (const [filename, content] of Object.entries(initialFiles)) {
-        await fs.outputFile(path.join(dir, filename), content);
-    }
+  // Write initial files
+  for (const [filename, content] of Object.entries(initialFiles)) {
+    await fs.outputFile(path.join(dir, filename), content);
+  }
 
-    await execa('git', ['add', '.'], { cwd: dir });
-    await execa('git', ['commit', '-m', 'Initial commit'], { cwd: dir });
+  await execa('git', ['add', '.'], { cwd: dir });
+  await execa('git', ['commit', '-m', 'Initial commit'], { cwd: dir });
 
-    return dir;
+  return dir;
 }