create-npkg 0.0.1 → 0.0.3

package/bin/create-npkg.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from '../dist/src/index.js';
+main();

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "create-npkg",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Create a new TypeScript npm package with best practices",
   "type": "module",
   "bin": {
-    "create-npkg": "./dist/src/index.js"
+    "create-npkg": "./bin/create-npkg.js"
   },
   "exports": "./dist/index.js",
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build",
-    "test": "node --test dist/test/**/*.test.js",
-    "test:watch": "node --test --watch dist/test/**/*.test.js"
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "create",

package/src/index.ts

@@ -1,468 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * create-npkg - Create a new TypeScript npm package
- */
-
-import fs from 'fs-extra';
-import path from 'path';
-import prompts from 'prompts';
-import kleur from 'kleur';
-import ora from 'ora';
-
-export interface Options {
-  pkgName: string;
-  description: string;
-  author: string;
-  license: string;
-  includeTests: boolean;
-  initGit: boolean;
-  installDeps: boolean;
-}
-
-export interface TemplateContext {
-  name: string;
-  description: string;
-  author: string;
-  license: string;
-  includeTests: boolean;
-  year: number;
-}
-
-/**
- * Validate package name according to npm naming rules
- */
-export function validatePackageName(name: string): { valid: boolean; error?: string } {
-  if (!name) {
-    return { valid: false, error: 'Package name is required' };
-  }
-  if (!/^[a-z0-9-]+$/.test(name)) {
-    return { valid: false, error: 'Package name must be lowercase, alphanumeric, and may contain hyphens' };
-  }
-  return { valid: true };
-}
-
-/**
- * Main CLI entry point
- */
-export async function main(): Promise<void> {
-  console.log('');
-  console.log(kleur.cyan('╔═══════════════════════════════════════╗'));
-  console.log(kleur.cyan('║') + kleur.bold('  create-npkg ') + kleur.cyan('                       ║'));
-  console.log(kleur.cyan('║') + kleur.dim('  Create a TypeScript npm package  ') + kleur.cyan('║'));
-  console.log(kleur.cyan('╚═══════════════════════════════════════╝'));
-  console.log('');
-
-  // Get package name from args or prompt
-  const args = process.argv.slice(2);
-  let pkgName = args[0];
-
-  // Check for flags
-  const noGitIndex = args.indexOf('--no-git');
-  const noInstallIndex = args.indexOf('--no-install');
-  const yesIndex = args.indexOf('--yes') !== -1 || args.indexOf('-y') !== -1;
-
-  const initGit = noGitIndex === -1;
-  const installDeps = noInstallIndex === -1;
-  const useDefaults = yesIndex;
-
-  // Remove flags from args if present
-  if (noGitIndex > 0) args.splice(noGitIndex, 1);
-  if (noInstallIndex > 0) args.splice(noInstallIndex, 1);
-
-  // Prompt for package name if not provided
-  if (!pkgName) {
-    const response = await prompts({
-      type: 'text',
-      name: 'pkgName',
-      message: 'What is your package name?',
-      initial: 'my-package',
-      validate: (value: string) => {
-        if (!value) return 'Package name is required';
-        if (!/^[a-z0-9-]+$/.test(value)) {
-          return 'Package name must be lowercase, alphanumeric, and may contain hyphens';
-        }
-        if (fs.existsSync(path.join(process.cwd(), value))) {
-          return `Directory "${value}" already exists`;
-        }
-        return true;
-      }
-    });
-    pkgName = response.pkgName;
-  }
-
-  if (!pkgName) {
-    console.error(kleur.red('✖ Package name is required'));
-    process.exit(1);
-  }
-
-  // Validate package name
-  if (!/^[a-z0-9-]+$/.test(pkgName)) {
-    console.error(kleur.red('✖ Package name must be lowercase, alphanumeric, and may contain hyphens'));
-    process.exit(1);
-  }
-
-  // Check if directory exists
-  const targetDir = path.join(process.cwd(), pkgName);
-  if (fs.existsSync(targetDir)) {
-    console.error(kleur.red(`✖ Directory "${pkgName}" already exists`));
-    process.exit(1);
-  }
-
-  // Prompt for additional options (or use defaults)
-  const responses = useDefaults ? {
-    description: 'A TypeScript package',
-    author: '',
-    license: 'MIT',
-    includeTests: false
-  } : await prompts(
-    [
-      {
-        type: 'text',
-        name: 'description',
-        message: 'Package description:',
-        initial: 'A TypeScript package'
-      },
-      {
-        type: 'text',
-        name: 'author',
-        message: 'Author:',
-        initial: ''
-      },
-      {
-        type: 'select',
-        name: 'license',
-        message: 'License:',
-        choices: [
-          { title: 'MIT', value: 'MIT' },
-          { title: 'Apache-2.0', value: 'Apache-2.0' },
-          { title: 'ISC', value: 'ISC' },
-          { title: 'BSD-3-Clause', value: 'BSD-3-Clause' }
-        ],
-        initial: 0
-      },
-      {
-        type: 'confirm',
-        name: 'includeTests',
-        message: 'Include testing setup?',
-        initial: false
-      }
-    ],
-    {
-      onCancel: () => {
-        console.log(kleur.yellow('✖ Operation cancelled'));
-        process.exit(0);
-      }
-    }
-  );
-
-  const options: Options = {
-    pkgName,
-    description: responses.description || 'A TypeScript package',
-    author: responses.author || '',
-    license: responses.license || 'MIT',
-    includeTests: responses.includeTests,
-    initGit,
-    installDeps
-  };
-
-  try {
-    await createPackage(options);
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(kleur.red(`✖ ${error.message}`));
-    }
-    process.exit(1);
-  }
-}
-
-/**
- * Create the package structure
- */
-export async function createPackage(options: Options, cwd: string = process.cwd()): Promise<void> {
-  const { pkgName } = options;
-  const targetDir = path.join(cwd, pkgName);
-
-  const spinner = ora('Creating package structure...').start();
-
-  try {
-    // Create directory
-    await fs.ensureDir(targetDir);
-    await fs.ensureDir(path.join(targetDir, 'src'));
-
-    // Template context
-    const context: TemplateContext = {
-      name: pkgName,
-      description: options.description,
-      author: options.author,
-      license: options.license,
-      includeTests: options.includeTests,
-      year: new Date().getFullYear()
-    };
-
-    // Write package.json
-    const pkgJson = generatePackageJson(context);
-    await fs.writeJSON(path.join(targetDir, 'package.json'), pkgJson, { spaces: 2 });
-
-    // Write tsconfig.json
-    const tsConfig = generateTsConfig(context);
-    await fs.writeJSON(path.join(targetDir, 'tsconfig.json'), tsConfig, { spaces: 2 });
-
-    // Write .gitignore
-    await fs.writeFile(path.join(targetDir, '.gitignore'), generateGitignore());
-
-    // Write README.md
-    await fs.writeFile(path.join(targetDir, 'README.md'), generateReadme(context));
-
-    // Write src/index.ts
-    await fs.writeFile(path.join(targetDir, 'src/index.ts'), generateIndexFile(context));
-
-    // Write test files if requested
-    if (options.includeTests) {
-      await fs.ensureDir(path.join(targetDir, 'tests'));
-      await fs.writeFile(path.join(targetDir, 'tests/index.test.ts'), generateTestFile(context));
-    }
-
-    spinner.succeed('Package structure created');
-
-    // Initialize git if requested
-    if (options.initGit) {
-      spinner.start('Initializing git repository');
-      const { spawn } = await import('child_process');
-      await new Promise<void>((resolve, reject) => {
-        const git = spawn('git', ['init'], { cwd: targetDir });
-        git.on('close', (code) => {
-          if (code === 0) resolve();
-          else reject(new Error('Git initialization failed'));
-        });
-      });
-      spinner.succeed('Git repository initialized');
-    }
-
-    // Install dependencies if requested
-    if (options.installDeps) {
-      spinner.start('Installing dependencies');
-      const { spawn } = await import('child_process');
-      await new Promise<void>((resolve, reject) => {
-        const npm = spawn('npm', ['install'], {
-          cwd: targetDir,
-          stdio: 'inherit'
-        });
-        npm.on('close', (code) => {
-          if (code === 0) resolve();
-          else reject(new Error('Dependency installation failed'));
-        });
-      });
-      spinner.succeed('Dependencies installed');
-    }
-
-    // Print success message
-    console.log('');
-    console.log(kleur.green('✓ Package created successfully!'));
-    console.log('');
-    console.log(kleur.bold('Next steps:'));
-    console.log(`  ${kleur.cyan(`cd ${pkgName}`)}`);
-    console.log(`  ${kleur.cyan('npm run dev')}`);
-    console.log('');
-
-  } catch (error) {
-    spinner.fail('Failed to create package');
-    throw error;
-  }
-}
-
-/**
- * Generate package.json
- */
-export function generatePackageJson(context: TemplateContext): Record<string, any> {
-  const devDependencies: Record<string, string> = {
-    '@types/node': '^20.11.0',
-    'typescript': '^5.3.3'
-  };
-
-  if (context.includeTests) {
-    devDependencies['@types/node'] = '^20.11.0';
-  }
-
-  return {
-    name: context.name,
-    version: '1.0.0',
-    type: 'module',
-    description: context.description,
-    main: './dist/index.js',
-    types: './dist/index.d.ts',
-    exports: {
-      '.': {
-        import: './dist/index.js',
-        types: './dist/index.d.ts'
-      }
-    },
-    files: ['dist'],
-    scripts: {
-      build: 'tsc',
-      dev: 'tsc --watch',
-      prepublishOnly: 'npm run build',
-      test: context.includeTests ? 'node --test' : undefined
-    },
-    keywords: [],
-    author: context.author,
-    license: context.license,
-    engines: {
-      node: '>=18.0.0'
-    },
-    devDependencies
-  };
-}
-
-/**
- * Generate tsconfig.json
- */
-export function generateTsConfig(_context: TemplateContext): Record<string, any> {
-  return {
-    compilerOptions: {
-      target: 'ES2022',
-      module: 'NodeNext',
-      moduleResolution: 'NodeNext',
-      lib: ['ES2022'],
-      declaration: true,
-      declarationMap: true,
-      sourceMap: true,
-      outDir: './dist',
-      rootDir: './src',
-      strict: true,
-      noImplicitAny: true,
-      strictNullChecks: true,
-      strictFunctionTypes: true,
-      strictBindCallApply: true,
-      strictPropertyInitialization: true,
-      noImplicitThis: true,
-      alwaysStrict: true,
-      noUnusedLocals: true,
-      noUnusedParameters: true,
-      noImplicitReturns: true,
-      noFallthroughCasesInSwitch: true,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      forceConsistentCasingInFileNames: true,
-      resolveJsonModule: true,
-      paths: {
-        '@src/*': ['./src/*']
-      }
-    },
-    include: ['src/**/*'],
-    exclude: ['node_modules', 'dist', '**/*.test.ts']
-  };
-}
-
-/**
- * Generate .gitignore
- */
-export function generateGitignore(): string {
-  return `# Dependencies
-node_modules/
-
-# Build output
-dist/
-
-# IDE
-.idea/
-.vscode/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Testing
-coverage/
-.nyc_output/
-
-# Environment
-.env
-.env.local
-`;
-}
-
-/**
- * Generate README.md
- */
-export function generateReadme(context: TemplateContext): string {
-  return `# ${context.name}
-
-${context.description}
-
-## Installation
-
-\`\`\`bash
-npm install ${context.name}
-\`\`\`
-
-## Usage
-
-\`\`\`typescript
-import { something } from '${context.name}';
-
-// Your code here
-\`\`\`
-
-## Development
-
-\`\`\`bash
-# Install dependencies
-npm install
-
-# Build
-npm run build
-
-# Watch mode
-npm run dev
-\`\`\`
-
-## License
-
-${context.license} © ${context.year} ${context.author ? context.author : 'Contributors'}
-`;
-}
-
-/**
- * Generate src/index.ts
- */
-export function generateIndexFile(_context: TemplateContext): string {
-  return `/**
- * Main entry point for ${_context.name}
- */
-
-export function hello(name: string): string {
-  return \`Hello, \${name}!\`;
-}
-
-export default hello;
-`;
-}
-
-/**
- * Generate test file
- */
-export function generateTestFile(_context: TemplateContext): string {
-  return `import { test } from 'node:test';
-import assert from 'node:assert';
-import { hello } from '../src/index.js';
-
-test('hello function', () => {
-  const result = hello('World');
-  assert.strictEqual(result, 'Hello, World!');
-});
-`;
-}
-
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main();
-}

package/test/index.test.ts

@@ -1,879 +0,0 @@
-/**
- * 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}`);
-  }
-});

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": ".",
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitThis": true,
-    "alwaysStrict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*", "test/**/*"],
-  "exclude": ["node_modules", "dist"]
-}