create-npkg 0.0.1

package/test/index.test.ts

@@ -0,0 +1,879 @@
+/**
+ * Tests for create-npkg
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs-extra';
+import path from 'path';
+import { tmpdir } from 'os';
+
+import {
+  validatePackageName,
+  generatePackageJson,
+  generateTsConfig,
+  generateGitignore,
+  generateReadme,
+  generateIndexFile,
+  generateTestFile,
+  createPackage,
+  type Options,
+  type TemplateContext
+} from '../src/index.js';
+
+// Helper to create a temporary directory
+async function createTempDir(): Promise<string> {
+  const tempDir = path.join(tmpdir(), `create-npkg-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  await fs.ensureDir(tempDir);
+  return tempDir;
+}
+
+// Helper to clean up a directory
+async function cleanupDir(dir: string): Promise<void> {
+  await fs.remove(dir);
+}
+
+test('validatePackageName - valid names', () => {
+  const validNames = [
+    'my-package',
+    'mypackage',
+    'my-package-123',
+    'package',
+    'a',
+    'test123'
+  ];
+
+  for (const name of validNames) {
+    const result = validatePackageName(name);
+    assert.strictEqual(result.valid, true, `Expected "${name}" to be valid`);
+    assert.strictEqual(result.error, undefined);
+  }
+});
+
+test('validatePackageName - invalid names', () => {
+  const invalidNames = [
+    { name: '', expectedError: 'Package name is required' },
+    { name: 'MyPackage', expectedError: 'lowercase' },
+    { name: 'my_package', expectedError: 'lowercase' },
+    { name: 'my package', expectedError: 'lowercase' },
+    { name: 'my@package', expectedError: 'lowercase' },
+    { name: '../malicious', expectedError: 'lowercase' }
+  ];
+
+  for (const { name, expectedError } of invalidNames) {
+    const result = validatePackageName(name);
+    assert.strictEqual(result.valid, false, `Expected "${name}" to be invalid`);
+    assert.ok(result.error?.includes(expectedError), `Expected error to contain "${expectedError}", got "${result.error}"`);
+  }
+});
+
+test('generatePackageJson - basic structure', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const pkgJson = generatePackageJson(context);
+
+  assert.strictEqual(pkgJson.name, 'test-package');
+  assert.strictEqual(pkgJson.version, '1.0.0');
+  assert.strictEqual(pkgJson.description, 'A test package');
+  assert.strictEqual(pkgJson.author, 'Test Author');
+  assert.strictEqual(pkgJson.license, 'MIT');
+  assert.strictEqual(pkgJson.main, './dist/index.js');
+  assert.strictEqual(pkgJson.types, './dist/index.d.ts');
+  assert.deepStrictEqual(pkgJson.files, ['dist']);
+  assert.ok(pkgJson.scripts.build);
+  assert.ok(pkgJson.scripts.dev);
+  assert.ok(pkgJson.scripts.prepublishOnly);
+  assert.strictEqual(pkgJson.engines.node, '>=18.0.0');
+  assert.ok(pkgJson.devDependencies);
+  assert.ok(pkgJson.devDependencies.typescript);
+});
+
+test('generatePackageJson - with tests', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: true,
+    year: 2024
+  };
+
+  const pkgJson = generatePackageJson(context);
+
+  assert.ok(pkgJson.scripts.test);
+  assert.strictEqual(pkgJson.scripts.test, 'node --test');
+});
+
+test('generatePackageJson - exports field', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const pkgJson = generatePackageJson(context);
+
+  assert.ok(pkgJson.exports);
+  assert.ok(pkgJson.exports['.']);
+  assert.ok(pkgJson.exports['.'].import);
+  assert.ok(pkgJson.exports['.'].types);
+  assert.strictEqual(pkgJson.exports['.'].import, './dist/index.js');
+  assert.strictEqual(pkgJson.exports['.'].types, './dist/index.d.ts');
+});
+
+test('generateTsConfig - strict configuration', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const tsConfig = generateTsConfig(context);
+
+  assert.ok(tsConfig.compilerOptions);
+  assert.strictEqual(tsConfig.compilerOptions.target, 'ES2022');
+  assert.strictEqual(tsConfig.compilerOptions.module, 'NodeNext');
+  assert.strictEqual(tsConfig.compilerOptions.moduleResolution, 'NodeNext');
+  assert.strictEqual(tsConfig.compilerOptions.outDir, './dist');
+  assert.strictEqual(tsConfig.compilerOptions.rootDir, './src');
+  assert.strictEqual(tsConfig.compilerOptions.strict, true);
+  assert.strictEqual(tsConfig.compilerOptions.noImplicitAny, true);
+  assert.strictEqual(tsConfig.compilerOptions.strictNullChecks, true);
+  assert.strictEqual(tsConfig.compilerOptions.declaration, true);
+  assert.strictEqual(tsConfig.compilerOptions.sourceMap, true);
+  assert.deepStrictEqual(tsConfig.include, ['src/**/*']);
+  assert.deepStrictEqual(tsConfig.exclude, ['node_modules', 'dist', '**/*.test.ts']);
+});
+
+test('generateTsConfig - path aliases', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const tsConfig = generateTsConfig(context);
+
+  assert.ok(tsConfig.compilerOptions.paths);
+  assert.ok(tsConfig.compilerOptions.paths['@src/*']);
+  assert.deepStrictEqual(tsConfig.compilerOptions.paths['@src/*'], ['./src/*']);
+});
+
+test('generateGitignore - contains essential patterns', () => {
+  const gitignore = generateGitignore();
+
+  assert.ok(gitignore.includes('node_modules/'));
+  assert.ok(gitignore.includes('dist/'));
+  assert.ok(gitignore.includes('.DS_Store'));
+  assert.ok(gitignore.includes('*.log'));
+  assert.ok(gitignore.includes('.env'));
+  assert.ok(gitignore.includes('.vscode/'));
+  assert.ok(gitignore.includes('.idea/'));
+});
+
+test('generateReadme - contains project information', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const readme = generateReadme(context);
+
+  assert.ok(readme.includes('# test-package'));
+  assert.ok(readme.includes('A test package'));
+  assert.ok(readme.includes('npm install test-package'));
+  assert.ok(readme.includes('MIT © 2024 Test Author'));
+  assert.ok(readme.includes('npm run build'));
+  assert.ok(readme.includes('npm run dev'));
+});
+
+test('generateReadme - without author', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: '',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const readme = generateReadme(context);
+
+  assert.ok(readme.includes('MIT © 2024 Contributors'));
+});
+
+test('generateIndexFile - contains valid TypeScript', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const indexFile = generateIndexFile(context);
+
+  assert.ok(indexFile.includes('export function hello'));
+  assert.ok(indexFile.includes('Main entry point for test-package'));
+  assert.ok(indexFile.includes('Hello, ${name}!'));
+  assert.ok(indexFile.includes('export default hello'));
+});
+
+test('generateTestFile - contains valid test code', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const testFile = generateTestFile(context);
+
+  assert.ok(testFile.includes("import { test } from 'node:test'"));
+  assert.ok(testFile.includes("import assert from 'node:assert'"));
+  assert.ok(testFile.includes("import { hello } from '../src/index.js'"));
+  assert.ok(testFile.includes("test('hello function'"));
+  assert.ok(testFile.includes("assert.strictEqual(result, 'Hello, World!')"));
+});
+
+test('createPackage - creates basic package structure', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg');
+
+    // Check directory exists
+    assert.ok(await fs.pathExists(pkgDir));
+
+    // Check files exist
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'package.json')));
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'tsconfig.json')));
+    assert.ok(await fs.pathExists(path.join(pkgDir, '.gitignore')));
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'README.md')));
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'src', 'index.ts')));
+
+    // Check src directory exists
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'src')));
+
+    // Check package.json content
+    const pkgJson = await fs.readJSON(path.join(pkgDir, 'package.json'));
+    assert.strictEqual(pkgJson.name, 'test-pkg');
+    assert.strictEqual(pkgJson.description, 'A test package');
+    assert.strictEqual(pkgJson.author, 'Test Author');
+    assert.strictEqual(pkgJson.license, 'MIT');
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - creates package with tests', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg-with-tests',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: true,
+      initGit: false,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg-with-tests');
+
+    // Check test directory and file exist
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'tests')));
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'tests', 'index.test.ts')));
+
+    // Check package.json has test script
+    const pkgJson = await fs.readJSON(path.join(pkgDir, 'package.json'));
+    assert.ok(pkgJson.scripts.test);
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - creates package with different license', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg-apache',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'Apache-2.0',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg-apache');
+
+    // Check package.json license
+    const pkgJson = await fs.readJSON(path.join(pkgDir, 'package.json'));
+    assert.strictEqual(pkgJson.license, 'Apache-2.0');
+
+    // Check README license
+    const readme = await fs.readFile(path.join(pkgDir, 'README.md'), 'utf-8');
+    assert.ok(readme.includes('Apache-2.0'));
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - generates valid TypeScript files', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg-valid-ts',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg-valid-ts');
+
+    // Read generated files
+    const indexContent = await fs.readFile(path.join(pkgDir, 'src', 'index.ts'), 'utf-8');
+    const tsConfig = await fs.readJSON(path.join(pkgDir, 'tsconfig.json'));
+
+    // Verify index.ts is valid TypeScript
+    assert.ok(indexContent.includes('export function hello'));
+    assert.ok(indexContent.includes(': string'));
+
+    // Verify tsconfig has proper settings
+    assert.strictEqual(tsConfig.compilerOptions.strict, true);
+    assert.strictEqual(tsConfig.compilerOptions.target, 'ES2022');
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - handles different author names', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg-author',
+      description: 'A test package',
+      author: 'John Doe <john@example.com>',
+      license: 'MIT',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg-author');
+
+    const pkgJson = await fs.readJSON(path.join(pkgDir, 'package.json'));
+    const readme = await fs.readFile(path.join(pkgDir, 'README.md'), 'utf-8');
+
+    assert.strictEqual(pkgJson.author, 'John Doe <john@example.com>');
+    assert.ok(readme.includes('John Doe <john@example.com>'));
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - generates proper directory structure', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg-structure',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg-structure');
+
+    // List all files in directory
+    const files = await fs.readdir(pkgDir);
+    const srcFiles = await fs.readdir(path.join(pkgDir, 'src'));
+
+    // Verify expected files
+    assert.ok(files.includes('package.json'));
+    assert.ok(files.includes('tsconfig.json'));
+    assert.ok(files.includes('.gitignore'));
+    assert.ok(files.includes('README.md'));
+    assert.ok(files.includes('src'));
+
+    // Verify src contents
+    assert.ok(srcFiles.includes('index.ts'));
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('generatePackageJson - handles empty author', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: '',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const pkgJson = generatePackageJson(context);
+
+  assert.strictEqual(pkgJson.author, '');
+});
+
+test('generatePackageJson - handles long descriptions', () => {
+  const longDesc = 'This is a very long package description that spans multiple lines and contains a lot of information about what the package does and how it can be used by developers in their projects.';
+
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: longDesc,
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const pkgJson = generatePackageJson(context);
+
+  assert.strictEqual(pkgJson.description, longDesc);
+});
+
+test('generateTsConfig - includes all necessary compiler options', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const tsConfig = generateTsConfig(context);
+  const opts = tsConfig.compilerOptions;
+
+  // Check for important strict mode options
+  assert.strictEqual(opts.strict, true);
+  assert.strictEqual(opts.noImplicitAny, true);
+  assert.strictEqual(opts.strictNullChecks, true);
+  assert.strictEqual(opts.strictFunctionTypes, true);
+  assert.strictEqual(opts.strictBindCallApply, true);
+  assert.strictEqual(opts.strictPropertyInitialization, true);
+  assert.strictEqual(opts.noImplicitThis, true);
+
+  // Check for modern JS target
+  assert.strictEqual(opts.target, 'ES2022');
+
+  // Check for module resolution
+  assert.strictEqual(opts.module, 'NodeNext');
+  assert.strictEqual(opts.moduleResolution, 'NodeNext');
+
+  // Check for declaration files
+  assert.strictEqual(opts.declaration, true);
+  assert.strictEqual(opts.declarationMap, true);
+  assert.strictEqual(opts.sourceMap, true);
+
+  // Check for output directory
+  assert.strictEqual(opts.outDir, './dist');
+  assert.strictEqual(opts.rootDir, './src');
+});
+
+// Boundary case tests
+test('validatePackageName - boundary cases', () => {
+  const boundaryCases = [
+    { name: '-', valid: true },  // Single hyphen is technically valid by regex
+    { name: 'package-', valid: true },
+    { name: '-package', valid: true },
+    { name: 'my--package', valid: true },
+    { name: 'a', valid: true },
+    { name: '1', valid: true },
+    { name: '1package', valid: true },
+    { name: 'package-1-2-3', valid: true }
+  ];
+
+  for (const { name, valid } of boundaryCases) {
+    const result = validatePackageName(name);
+    assert.strictEqual(result.valid, valid, `Expected "${name}" to be ${valid ? 'valid' : 'invalid'}`);
+  }
+});
+
+test('validatePackageName - npm reserved keywords', () => {
+  const reservedNames = [
+    'node',
+    'npm',
+    'fs',
+    'path',
+    'http',
+    'https',
+    'stream',
+    'events',
+    'util',
+    'os'
+  ];
+
+  // Note: Current implementation allows these, but tests document current behavior
+  for (const name of reservedNames) {
+    const result = validatePackageName(name);
+    assert.strictEqual(result.valid, true, `Currently allows reserved name "${name}"`);
+  }
+});
+
+test('validatePackageName - special characters', () => {
+  const specialCases = [
+    { name: 'my.package', valid: false },
+    { name: 'my_package', valid: false },
+    { name: 'my@package', valid: false },
+    { name: 'my+package', valid: false },
+    { name: 'my~package', valid: false },
+    { name: 'my package', valid: false },
+    { name: 'my\npackage', valid: false },
+    { name: 'my\tpackage', valid: false }
+  ];
+
+  for (const { name, valid } of specialCases) {
+    const result = validatePackageName(name);
+    assert.strictEqual(result.valid, valid, `Expected "${name}" to be ${valid ? 'valid' : 'invalid'}`);
+  }
+});
+
+test('generatePackageJson - includes type module', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const pkgJson = generatePackageJson(context);
+  assert.strictEqual(pkgJson.type, 'module');
+});
+
+test('generatePackageJson - handles special characters in author', () => {
+  const specialAuthors = [
+    'John Doe <john@example.com>',
+    'Jane Doe <jane@example.com> (https://jane.dev)',
+    'Åsa ÄäÖö',
+    'Developer "The Dev" Smith'
+  ];
+
+  for (const author of specialAuthors) {
+    const context: TemplateContext = {
+      name: 'test-package',
+      description: 'A test package',
+      author,
+      license: 'MIT',
+      includeTests: false,
+      year: 2024
+    };
+
+    const pkgJson = generatePackageJson(context);
+    assert.strictEqual(pkgJson.author, author);
+  }
+});
+
+test('generatePackageJson - handles very long description', () => {
+  const longDesc = 'A'.repeat(10000);
+
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: longDesc,
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const pkgJson = generatePackageJson(context);
+  assert.strictEqual(pkgJson.description.length, 10000);
+});
+
+test('generateReadme - handles special characters in description', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A package with <special> & "characters" and \'quotes\'',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const readme = generateReadme(context);
+  assert.ok(readme.includes('A package with <special> & "characters" and \'quotes\''));
+});
+
+test('createPackage - handles errors gracefully', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    // Create a file with the same name as the target package
+    const options: Options = {
+      pkgName: 'test-pkg',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    // Create a file instead of directory
+    const filePath = path.join(tempDir, 'test-pkg');
+    await fs.writeFile(filePath, 'This is a file, not a directory');
+
+    // Should fail because test-pkg exists as a file
+    await assert.rejects(
+      async () => await createPackage(options, tempDir),
+      /EEXIST|already exists|file already exists/
+    );
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - with git initialization', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg-git',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: false,
+      initGit: true,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg-git');
+    const gitDir = path.join(pkgDir, '.git');
+
+    // Check .git directory was created
+    assert.ok(await fs.pathExists(gitDir));
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - creates proper test directory structure', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options: Options = {
+      pkgName: 'test-pkg-tests',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: true,
+      initGit: false,
+      installDeps: false
+    };
+
+    await createPackage(options, tempDir);
+
+    const pkgDir = path.join(tempDir, 'test-pkg-tests');
+
+    // Check tests directory exists
+    assert.ok(await fs.pathExists(path.join(pkgDir, 'tests')));
+
+    // Check test file exists and has correct content
+    const testContent = await fs.readFile(path.join(pkgDir, 'tests', 'index.test.ts'), 'utf-8');
+    assert.ok(testContent.includes("import { test } from 'node:test'"));
+    assert.ok(testContent.includes("import assert from 'node:assert'"));
+    assert.ok(testContent.includes('hello'));
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('generateTsConfig - excludes test files', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const tsConfig = generateTsConfig(context);
+  assert.ok(tsConfig.exclude.includes('**/*.test.ts'));
+});
+
+test('generateTsConfig - includes all strict options', () => {
+  const context: TemplateContext = {
+    name: 'test-package',
+    description: 'A test package',
+    author: 'Test Author',
+    license: 'MIT',
+    includeTests: false,
+    year: 2024
+  };
+
+  const tsConfig = generateTsConfig(context);
+  const opts = tsConfig.compilerOptions;
+
+  // Verify esModuleInterop is present (was an indentation bug)
+  assert.strictEqual(opts.esModuleInterop, true);
+
+  // Verify other important options
+  assert.strictEqual(opts.alwaysStrict, true);
+  assert.strictEqual(opts.noUnusedLocals, true);
+  assert.strictEqual(opts.noUnusedParameters, true);
+  assert.strictEqual(opts.noImplicitReturns, true);
+  assert.strictEqual(opts.noFallthroughCasesInSwitch, true);
+});
+
+test('createPackage - all licenses generate correctly', async () => {
+  const licenses = ['MIT', 'Apache-2.0', 'ISC', 'BSD-3-Clause'];
+  const tempDir = await createTempDir();
+
+  try {
+    for (const license of licenses) {
+      const options: Options = {
+        pkgName: `test-pkg-${license.toLowerCase().replace('.', '-')}`,
+        description: 'A test package',
+        author: 'Test Author',
+        license,
+        includeTests: false,
+        initGit: false,
+        installDeps: false
+      };
+
+      await createPackage(options, tempDir);
+
+      const pkgDir = path.join(tempDir, options.pkgName);
+      const pkgJson = await fs.readJSON(path.join(pkgDir, 'package.json'));
+
+      assert.strictEqual(pkgJson.license, license);
+    }
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('createPackage - handles concurrent package creation', async () => {
+  const tempDir = await createTempDir();
+
+  try {
+    const options1: Options = {
+      pkgName: 'test-pkg-1',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    const options2: Options = {
+      pkgName: 'test-pkg-2',
+      description: 'A test package',
+      author: 'Test Author',
+      license: 'MIT',
+      includeTests: false,
+      initGit: false,
+      installDeps: false
+    };
+
+    // Create packages concurrently
+    await Promise.all([
+      createPackage(options1, tempDir),
+      createPackage(options2, tempDir)
+    ]);
+
+    // Verify both packages exist
+    assert.ok(await fs.pathExists(path.join(tempDir, 'test-pkg-1')));
+    assert.ok(await fs.pathExists(path.join(tempDir, 'test-pkg-2')));
+
+  } finally {
+    await cleanupDir(tempDir);
+  }
+});
+
+test('generateGitignore - covers all essential patterns', () => {
+  const gitignore = generateGitignore();
+  const requiredPatterns = [
+    'node_modules/',
+    'dist/',
+    '.DS_Store',
+    'Thumbs.db',
+    '*.log',
+    '.env',
+    '.vscode/',
+    '.idea/',
+    '*.swp',
+    '*.swo',
+    'coverage/',
+    '.nyc_output/',
+    'env.local'
+  ];
+
+  for (const pattern of requiredPatterns) {
+    assert.ok(gitignore.includes(pattern), `Missing pattern: ${pattern}`);
+  }
+});