create-npkg 0.0.1

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "create-npkg",
+  "version": "0.0.1",
+  "description": "Create a new TypeScript npm package with best practices",
+  "type": "module",
+  "bin": {
+    "create-npkg": "./dist/src/index.js"
+  },
+  "exports": "./dist/index.js",
+  "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"
+  },
+  "keywords": [
+    "create",
+    "typescript",
+    "npm",
+    "package",
+    "scaffold",
+    "generator"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "prompts": "^2.4.2",
+    "kleur": "^4.1.5",
+    "ora": "^6.3.1",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.3.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,468 @@
+#!/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();
+}