itty-packager 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,219 @@
+<br />
+
+<p>
+<a href="https://itty.dev/itty-packager" target="_blank">
+  <img src="https://github.com/user-attachments/assets/placeholder-image" alt="itty-packager" height="120" />
+</a>
+</p>
+
+[![Version](https://img.shields.io/npm/v/itty-packager.svg?style=flat-square)](https://npmjs.com/package/itty-packager)
+[![Bundle Size](https://deno.bundlejs.com/?q=itty-packager&badge&badge-style=flat-square)](https://deno.bundlejs.com/?q=itty-packager)
+[![Coverage Status](https://img.shields.io/coveralls/github/kwhitley/itty-packager?style=flat-square)](https://coveralls.io/github/kwhitley/itty-packager)
+[![Issues](https://img.shields.io/github/issues/kwhitley/itty-packager?style=flat-square)](https://github.com/kwhitley/itty-packager/issues)
+[![Discord](https://img.shields.io/discord/832353585802903572?label=Discord&logo=Discord&style=flat-square&logoColor=fff)](https://discord.gg/53vyrZAu9u)
+
+### [Documentation](https://itty.dev) &nbsp;| &nbsp; [Discord](https://discord.gg/53vyrZAu9u)
+
+---
+
+# Universal toolkit for itty libraries
+
+Zero-config build, lint, and publish workflows for TypeScript libraries.
+
+## Features
+
+- **🔨 Build** - TypeScript compilation with Rollup, minification, and snippet generation
+- **🔍 Lint** - Built-in ESLint configuration with TypeScript support and smart extending
+- **📦 Publish** - Automated version bumping, clean package extraction, and npm publishing
+- **⚡ Zero Config** - Works out of the box, customize only what you need
+- **🎯 Consistent** - Unified tooling across all itty projects
+
+## Installation
+
+```bash
+npm install --save-dev itty-packager
+```
+
+## Quick Start
+
+Add to your `package.json` scripts:
+
+```json
+{
+  "scripts": {
+    "build": "itty build",
+    "lint": "itty lint", 
+    "publish": "itty publish"
+  }
+}
+```
+
+## Commands
+
+### `itty build`
+
+Build your TypeScript library with Rollup, TypeScript compilation, and optional minification.
+
+**Usage:** `itty build [options]`
+
+**Options:**
+- `-f, --from <dir>` - Source directory (default: `src`)
+- `-o, --out <dir>` - Output directory (default: `dist`) 
+- `-c, --copy <files>` - Files to copy to output (comma-separated)
+- `--sourcemap` - Generate source maps (default: `false`)
+- `--hybrid` - Build both ESM and CJS (default: ESM only)
+- `--minify` - Minify output with terser (default: `true`)
+- `--no-minify` - Skip minification
+- `-s, --snippet <name>` - Generate snippet file for README injection
+- `-h, --help` - Show help
+
+**Default Behavior:**
+- Compiles all TypeScript files from `src/` to `dist/`
+- Generates ESM (`.mjs`) output only
+- Minifies output by default
+- Updates `package.json` exports with correct paths
+- Single file exports map to root export, multiple files get individual exports
+
+**Examples:**
+```bash
+itty build                              # Basic ESM build, minified
+itty build --hybrid --sourcemap        # Build both ESM/CJS with sourcemaps  
+itty build --snippet=connect           # Build with snippet generation for README
+itty build --from=lib --out=build      # Build from lib/ to build/
+```
+
+### `itty lint`
+
+Lint your code with ESLint using built-in TypeScript configuration or your local config.
+
+**Usage:** `itty lint [files/directories] [options]`
+
+**Options:**
+- `--fix` - Automatically fix problems
+- `--max-warnings <n>` - Number of warnings to trigger nonzero exit code
+- `-q, --quiet` - Report errors only
+- `-f, --format <format>` - Output format (stylish, compact, json, etc.)
+- `-h, --help` - Show help
+
+**Default Behavior:**
+- Uses built-in TypeScript ESLint config if no local config found
+- Lints entire project excluding `node_modules/`, `dist/`, `build/`, `coverage/`
+- Local configs (`.eslintrc.*`, `eslint.config.*`) override built-in config
+- All ESLint dependencies provided by itty-packager
+
+**Config Extension:**
+Create `eslint.config.mjs` to extend the built-in config:
+```javascript
+import { createConfig } from 'itty-packager/lib/configs/createConfig.mjs'
+
+export default createConfig({
+  rules: {
+    'no-console': 'off',  // Project-specific overrides
+  }
+})
+```
+
+**Examples:**
+```bash
+itty lint                    # Lint entire project with smart exclusions
+itty lint src               # Lint only src directory
+itty lint --fix             # Lint and auto-fix issues
+itty lint --format=json     # Output results in JSON format
+```
+
+### `itty publish`
+
+Version bump and publish your package to npm with clean, flat package structure.
+
+**Usage:** `itty publish [options]`
+
+**Version Options (default: patch):**
+- `--major` - Major release X.#.# for breaking changes
+- `--minor` - Minor release #.X.# for feature additions
+- `--patch` - Patch release #.#.X for bug fixes (default)
+- `--type <type>` - Custom release type (alpha, beta, rc, etc.)
+
+**Publish Options:**
+- `--src <dir>` - Source directory to publish from (default: `dist`)
+- `--dest <dir>` - Temporary directory for publishing (default: `.dist`)
+- `--dry-run` - Build and prepare but do not publish
+- `--no-cleanup` - Leave temporary directory after publishing
+- `--public` - Publish as public package (`--access=public`)
+- `--no-license` - Do not copy LICENSE file to published package
+- `--no-changelog` - Do not copy CHANGELOG.md file to published package
+
+**Git Options:**
+- `--tag` - Create git tag for release
+- `--push` - Push changes and tags to git remote
+- `--no-git` - Skip all git operations
+
+**Default Behavior:**
+- Defaults to patch version bump if no type specified
+- Extracts build artifacts to temporary directory
+- Copies root files: `README.md`, `LICENSE`, `CHANGELOG.md`, `.npmrc` (if they exist)
+- Transforms package.json paths (e.g., `./dist/file.mjs` → `./file.mjs`)
+- Creates clean, flat package structure in node_modules
+
+**Examples:**
+```bash
+itty publish                   # Patch bump and publish from dist/ (default)
+itty publish --minor --tag     # Minor bump, publish, and create git tag
+itty publish --type=alpha      # Pre-release alpha version
+itty publish --dry-run         # Test the publish process
+itty publish --no-license      # Publish without copying LICENSE file
+```
+
+## Package Structure
+
+The publish command creates a clean package structure by:
+
+1. **Extracting build artifacts** from your `dist/` directory to package root
+2. **Copying essential files** like README, LICENSE, CHANGELOG
+3. **Transforming paths** in package.json to point to root-level files
+4. **Publishing the clean structure** so users get flat imports
+
+**Before (in your project):**
+```
+package.json exports: "./dist/connect.mjs"
+dist/connect.mjs
+README.md
+LICENSE
+```
+
+**After (in node_modules):**
+```
+package.json exports: "./connect.mjs"  
+connect.mjs
+README.md
+LICENSE
+```
+
+## Configuration
+
+### ESLint
+
+The built-in ESLint config includes:
+- TypeScript support with `@typescript-eslint`
+- Sensible defaults for itty projects
+- Unix line endings, single quotes, no semicolons
+- Disabled rules: `no-empty-function`, `no-explicit-any`, `ban-types`, `ban-ts-comment`
+
+Override by creating `eslint.config.mjs` in your project root.
+
+### Package.json
+
+Add itty-packager to your scripts for easy access:
+
+```json
+{
+  "scripts": {
+    "build": "itty build --snippet=mylib --hybrid",
+    "lint": "itty lint",
+    "publish": "itty publish --tag --push"
+  }
+}
+```
+
+## License
+
+MIT

package/bin/itty.js

@@ -4,8 +4,9 @@ import { parseArgs } from 'node:util'
 
 const subcommands = {
   build: () => import('../lib/commands/build.js').then(m => m.buildCommand),
+  lint: () => import('../lib/commands/lint.js').then(m => m.lintCommand),
+  publish: () => import('../lib/commands/publish.js').then(m => m.publishCommand),
   // Future subcommands can be added here:
-  // release: () => import('../lib/commands/release.js').then(m => m.releaseCommand),
   // deploy: () => import('../lib/commands/deploy.js').then(m => m.deployCommand),
 }
 
@@ -71,6 +72,8 @@ Usage: itty <subcommand> [options]
 
 Subcommands:
   build     Build your library with rollup and typescript
+  lint      Lint your code with ESLint
+  publish   Version and publish your package to npm
 
 Global Options:
   -h, --help      Show help
@@ -79,6 +82,10 @@ Global Options:
 Examples:
   itty build --snippet=connect --hybrid    # Build with snippet and CJS support
   itty build --sourcemap --no-minify      # Build with sourcemaps, no minification
+  itty lint                               # Lint entire project (smart exclusions)
+  itty lint src                           # Lint only the src directory
+  itty lint --fix                         # Lint and fix issues automatically
+  itty publish --patch                    # Version bump and publish from dist/
   itty build --help                       # Show build-specific help
 
 Run 'itty <subcommand> --help' for subcommand-specific options.

package/eslint.config.mjs

@@ -0,0 +1,26 @@
+import { createConfig } from './lib/configs/createConfig.mjs'
+
+export default createConfig({
+  rules: {
+    // Allow console statements in CLI tools
+    'no-console': 'off',
+    
+    // Allow process global in Node.js CLI
+    'no-undef': 'off',
+    
+    // Allow useless escapes in regex patterns
+    'no-useless-escape': 'off',
+  },
+  
+  languageOptions: {
+    globals: {
+      // Node.js globals
+      process: 'readonly',
+      console: 'readonly',
+      Buffer: 'readonly',
+      __dirname: 'readonly',
+      __filename: 'readonly',
+      global: 'readonly',
+    }
+  }
+})

package/lib/builder.js

@@ -14,7 +14,7 @@ export async function build(options = {}) {
   const {
     from = 'src',
     out = 'dist',
-    copy: copyFiles = 'LICENSE',
+    copy: copyFiles,
     snippet,
     sourcemap = false,
     hybrid = false,
@@ -207,7 +207,7 @@ async function injectSnippet(snippetName, outDir) {
   if (await fs.pathExists(readmePath)) {
     const readme = await fs.readFile(readmePath, 'utf-8')
     const newReadme = readme.replace(
-      /(<!-- BEGIN SNIPPET -->[\r\n]+```(?:js|ts)[\r\n]).*?([\r\n]```[\r\n]+<!-- END SNIPPET -->)/s,
+      /(<!-- BEGIN SNIPPET -->[\r\n]+```(?:js|ts)[\r\n]?).*?([\r\n]?```[\r\n]+<!-- END SNIPPET -->)/s,
       `$1${transformed}$2`
     )
     

package/lib/commands/build.js

@@ -5,11 +5,6 @@ export async function buildCommand(args) {
   const { values: buildArgs } = parseArgs({
     args,
     options: {
-      snippet: {
-        type: 'string',
-        short: 's',
-        description: 'Generate snippet file for README injection'
-      },
       from: {
         type: 'string',
         short: 'f',
@@ -25,8 +20,7 @@ export async function buildCommand(args) {
       copy: {
         type: 'string',
         short: 'c',
-        default: 'LICENSE',
-        description: 'Files to copy to output (default: LICENSE)'
+        description: 'Files to copy to output (comma-separated)'
       },
       sourcemap: {
         type: 'boolean',
@@ -44,6 +38,11 @@ export async function buildCommand(args) {
         type: 'boolean',
         description: 'Skip minification'
       },
+      snippet: {
+        type: 'string',
+        short: 's',
+        description: 'Generate snippet file for README injection'
+      },
       help: {
         type: 'boolean',
         short: 'h',
@@ -60,22 +59,22 @@ itty build - Build your library with rollup and typescript
 Usage: itty build [options]
 
 Options:
-  -s, --snippet <name>    Generate snippet file for README injection
   -f, --from <dir>        Source directory (default: src)
   -o, --out <dir>         Output directory (default: dist)
-  -c, --copy <files>      Files to copy to output (default: LICENSE)
+  -c, --copy <files>      Files to copy to output (comma-separated)
       --sourcemap         Generate source maps (default: false)
       --hybrid            Build both ESM and CJS (default: ESM only)
       --minify            Minify output with terser (default: true)
       --no-minify         Skip minification
+  -s, --snippet <name>    Generate snippet file for README injection
   -h, --help              Show help
 
 Examples:
   itty build                              # Build ESM only, minified, no sourcemaps
-  itty build --snippet=connect           # Build with connect snippet generation
   itty build --hybrid --sourcemap        # Build both ESM/CJS with sourcemaps
   itty build --no-minify                 # Build without minification
   itty build --from=lib --out=build      # Build from lib/ to build/
+  itty build --snippet=connect           # Build with connect snippet generation
 `)
     return
   }

package/lib/commands/lint.js

@@ -0,0 +1,174 @@
+import { parseArgs } from 'node:util'
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import fs from 'fs-extra'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export async function lintCommand(args) {
+  const { values: lintArgs, positionals } = parseArgs({
+    args,
+    options: {
+      fix: {
+        type: 'boolean',
+        description: 'Automatically fix problems'
+      },
+      'max-warnings': {
+        type: 'string',
+        description: 'Number of warnings to trigger nonzero exit code'
+      },
+      quiet: {
+        type: 'boolean',
+        short: 'q',
+        description: 'Report errors only'
+      },
+      format: {
+        type: 'string',
+        short: 'f',
+        description: 'Output format (stylish, compact, json, etc.)'
+      },
+      help: {
+        type: 'boolean',
+        short: 'h',
+        description: 'Show help'
+      }
+    },
+    allowPositionals: true,
+    strict: false
+  })
+
+  if (lintArgs.help) {
+    console.log(`
+itty lint - Lint your code with ESLint
+
+Usage: itty lint [files/directories] [options]
+
+Options:
+      --fix               Automatically fix problems
+      --max-warnings <n>  Number of warnings to trigger nonzero exit code
+  -q, --quiet             Report errors only
+  -f, --format <format>   Output format (stylish, compact, json, etc.)
+  -h, --help              Show help
+
+Examples:
+  itty lint                    # Lint entire project (excludes node_modules, dist, build, etc.)
+  itty lint src               # Lint only src directory
+  itty lint --fix             # Lint entire project and auto-fix issues
+  itty lint src --quiet       # Lint src directory, show errors only
+  itty lint --format=json     # Lint entire project, output in JSON format
+
+Note: 
+- When no paths are specified, lints entire project excluding common build directories
+- Uses built-in TypeScript ESLint config if no local config found
+- Local configs (eslint.config.mjs, .eslintrc.*, etc.) will override built-in config
+- To extend built-in config: import { createConfig } from 'itty-packager/lib/configs/createConfig.mjs'
+- Use specific paths to override the default exclusions
+`)
+    return
+  }
+
+  // Check for local ESLint configs
+  const cwd = process.cwd()
+  const localConfigFiles = [
+    'eslint.config.mjs',
+    'eslint.config.js', 
+    '.eslintrc.mjs',
+    '.eslintrc.js',
+    '.eslintrc.json',
+    '.eslintrc'
+  ]
+  
+  const hasLocalConfig = localConfigFiles.some(file => 
+    fs.existsSync(path.join(cwd, file))
+  )
+  
+  // Find itty-packager's path and config
+  const packagerPath = path.resolve(__dirname, '../../')
+  const builtinConfig = path.join(packagerPath, 'lib', 'configs', 'eslint.config.mjs')
+  
+  // Check if we're in development (has node_modules) or published (use npx)
+  const isDevMode = await fs.pathExists(path.join(packagerPath, 'node_modules'))
+  const eslintBinary = isDevMode 
+    ? path.join(packagerPath, 'node_modules', '.bin', 'eslint')
+    : 'eslint'  // Use npx approach for published version
+  
+  const eslintArgs = []
+  
+  // Use built-in config if no local config exists
+  if (!hasLocalConfig) {
+    console.log(`🔧 Using built-in ESLint config (no local config found)`)
+    eslintArgs.push('--config', builtinConfig)
+  } else {
+    console.log(`🔧 Using local ESLint config`)
+  }
+  
+  // Add positional arguments (files/directories to lint)
+  if (positionals.length > 0) {
+    eslintArgs.push(...positionals)
+  } else {
+    // Default to all JS/TS files, excluding common build directories
+    eslintArgs.push(
+      '.',
+      '--ignore-pattern', 'node_modules/',
+      '--ignore-pattern', 'dist/',
+      '--ignore-pattern', 'build/',
+      '--ignore-pattern', 'coverage/',
+      '--ignore-pattern', '*.min.js',
+      '--ignore-pattern', '*.bundle.js'
+    )
+  }
+  
+  // Add flags
+  if (lintArgs.fix) {
+    eslintArgs.push('--fix')
+  }
+  
+  if (lintArgs['max-warnings']) {
+    eslintArgs.push('--max-warnings', lintArgs['max-warnings'])
+  }
+  
+  if (lintArgs.quiet) {
+    eslintArgs.push('--quiet')
+  }
+  
+  if (lintArgs.format) {
+    eslintArgs.push('--format', lintArgs.format)
+  }
+
+  console.log(`🔍 Linting with ESLint...`)
+  
+  // Run ESLint
+  return new Promise((resolve, reject) => {
+    const useNpx = !isDevMode
+    const command = useNpx ? 'npx' : eslintBinary
+    const args = useNpx ? ['eslint', ...eslintArgs] : eslintArgs
+    
+    // Set up environment with access to itty-packager's node_modules for ESLint plugins
+    const env = { 
+      ...process.env,
+      NODE_PATH: `${path.join(packagerPath, 'node_modules')}:${process.env.NODE_PATH || ''}`
+    }
+    
+    const eslint = spawn(command, args, {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+      shell: true,
+      env
+    })
+
+    eslint.on('close', (code) => {
+      if (code === 0) {
+        console.log('✅ Linting completed successfully')
+        resolve()
+      } else {
+        reject(new Error(`ESLint exited with code ${code}`))
+      }
+    })
+
+    eslint.on('error', (error) => {
+      reject(new Error(`Failed to run ESLint: ${error.message}`))
+    })
+  })
+}

package/lib/commands/publish.js

@@ -0,0 +1,368 @@
+import { parseArgs } from 'node:util'
+import { spawn } from 'node:child_process'
+import fs from 'fs-extra'
+import path from 'node:path'
+
+const SEMVER_TYPES = ['major', 'minor', 'patch']
+
+function transformPackageExports(pkg, srcDir) {
+  // Transform package.json exports to remove srcDir prefix from paths
+  if (pkg.exports) {
+    const transformPath = (exportPath) => {
+      if (typeof exportPath === 'string' && exportPath.startsWith(`./${srcDir}/`)) {
+        return exportPath.replace(`./${srcDir}/`, './')
+      }
+      return exportPath
+    }
+
+    const transformExportObj = (exportObj) => {
+      if (typeof exportObj === 'string') {
+        return transformPath(exportObj)
+      }
+      
+      if (typeof exportObj === 'object' && exportObj !== null) {
+        const transformed = {}
+        for (const [key, value] of Object.entries(exportObj)) {
+          if (typeof value === 'string') {
+            transformed[key] = transformPath(value)
+          } else if (typeof value === 'object') {
+            transformed[key] = transformExportObj(value)
+          } else {
+            transformed[key] = value
+          }
+        }
+        return transformed
+      }
+      
+      return exportObj
+    }
+
+    const transformedExports = {}
+    for (const [key, value] of Object.entries(pkg.exports)) {
+      transformedExports[key] = transformExportObj(value)
+    }
+    
+    return { ...pkg, exports: transformedExports }
+  }
+  
+  return pkg
+}
+
+function versionBump(currentVersion, type) {
+  const parts = currentVersion.split('.').map(Number)
+  
+  switch (type) {
+    case 'major':
+      return `${parts[0] + 1}.0.0`
+    case 'minor':
+      return `${parts[0]}.${parts[1] + 1}.0`
+    case 'patch':
+      return `${parts[0]}.${parts[1]}.${parts[2] + 1}`
+    default:
+      // For pre-release versions like alpha, beta, rc
+      if (currentVersion.includes(`-${type}`)) {
+        // Increment the pre-release number
+        const [base, prerelease] = currentVersion.split(`-${type}.`)
+        const prereleaseNum = parseInt(prerelease) || 0
+        return `${base}-${type}.${prereleaseNum + 1}`
+      } else {
+        // Add pre-release to current version
+        return `${currentVersion}-${type}.0`
+      }
+  }
+}
+
+async function runCommand(command, cwd = process.cwd()) {
+  return new Promise((resolve, reject) => {
+    const [cmd, ...args] = command.split(' ')
+    const proc = spawn(cmd, args, {
+      stdio: 'inherit',
+      cwd,
+      shell: true
+    })
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve()
+      } else {
+        reject(new Error(`Command failed with exit code ${code}: ${command}`))
+      }
+    })
+
+    proc.on('error', (error) => {
+      reject(new Error(`Failed to run command: ${error.message}`))
+    })
+  })
+}
+
+export async function publishCommand(args) {
+  const { values: publishArgs } = parseArgs({
+    args,
+    options: {
+      major: {
+        type: 'boolean',
+        description: 'Major release X.#.# for breaking changes'
+      },
+      minor: {
+        type: 'boolean',
+        description: 'Minor release #.X.# for feature additions'
+      },
+      patch: {
+        type: 'boolean',
+        description: 'Patch release #.#.X for bug fixes'
+      },
+      type: {
+        type: 'string',
+        description: 'Custom release type (alpha, beta, rc, etc.)'
+      },
+      src: {
+        type: 'string',
+        default: 'dist',
+        description: 'Source directory to publish from (default: dist)'
+      },
+      dest: {
+        type: 'string',
+        default: '.dist',
+        description: 'Temporary directory for publishing (default: .dist)'
+      },
+      'dry-run': {
+        type: 'boolean',
+        description: 'Build and prepare but do not publish'
+      },
+      'no-cleanup': {
+        type: 'boolean',
+        description: 'Leave temporary directory after publishing'
+      },
+      public: {
+        type: 'boolean',
+        description: 'Publish as public package (--access=public)'
+      },
+      tag: {
+        type: 'boolean',
+        description: 'Create git tag for release'
+      },
+      push: {
+        type: 'boolean',
+        description: 'Push changes and tags to git remote'
+      },
+      'no-git': {
+        type: 'boolean',
+        description: 'Skip all git operations'
+      },
+      'no-license': {
+        type: 'boolean',
+        description: 'Do not copy LICENSE file to published package'
+      },
+      'no-changelog': {
+        type: 'boolean',
+        description: 'Do not copy CHANGELOG.md file to published package'
+      },
+      help: {
+        type: 'boolean',
+        short: 'h',
+        description: 'Show help'
+      }
+    },
+    allowPositionals: false
+  })
+
+  if (publishArgs.help) {
+    console.log(`
+itty publish - Version and publish your package to npm
+
+Usage: itty publish [options]
+
+Version Options (default: patch):
+      --major             Major release X.#.# for breaking changes
+      --minor             Minor release #.X.# for feature additions  
+      --patch             Patch release #.#.X for bug fixes (default)
+      --type <type>       Custom release type (alpha, beta, rc, etc.)
+
+Publish Options:
+      --src <dir>         Source directory to publish from (default: dist)
+      --dest <dir>        Temporary directory for publishing (default: .dist)
+      --dry-run           Build and prepare but do not publish
+      --no-cleanup        Leave temporary directory after publishing
+      --public            Publish as public package (--access=public)
+      --no-license        Do not copy LICENSE file to published package
+      --no-changelog      Do not copy CHANGELOG.md file to published package
+
+Git Options:
+      --tag               Create git tag for release
+      --push              Push changes and tags to git remote
+      --no-git            Skip all git operations
+  -h, --help              Show help
+
+Examples:
+  itty publish                   # Patch version bump and publish from dist/ (default)
+  itty publish --minor --tag     # Minor bump, publish, and create git tag
+  itty publish --type=alpha      # Pre-release alpha version
+  itty publish --src=lib         # Publish from lib/ instead of dist/
+  itty publish --dry-run         # Test the publish process
+
+Note: This command extracts your build artifacts to a temporary directory,
+adds root files (README.md, LICENSE, etc.), and publishes from there.
+This creates a clean, flat package structure in node_modules.
+`)
+    return
+  }
+
+  // Determine release type (default to patch)
+  const releaseType = publishArgs.major ? 'major' 
+                    : publishArgs.minor ? 'minor'
+                    : publishArgs.patch ? 'patch'
+                    : publishArgs.type ? publishArgs.type
+                    : 'patch' // Default to patch
+
+  const rootPath = process.cwd()
+  const srcDir = path.join(rootPath, publishArgs.src)
+  
+  // Handle root publishing (src=.) by using a different temp directory structure
+  const isRootPublish = publishArgs.src === '.'
+  const tempDir = isRootPublish 
+    ? path.join(path.dirname(rootPath), `.${path.basename(rootPath)}-dist`)
+    : path.join(rootPath, publishArgs.dest)
+  const dryRun = publishArgs['dry-run']
+  const noCleanup = publishArgs['no-cleanup']
+  const publicAccess = publishArgs.public
+  const shouldTag = publishArgs.tag
+  const shouldPush = publishArgs.push
+  const noGit = publishArgs['no-git']
+  const noLicense = publishArgs['no-license']
+  const noChangelog = publishArgs['no-changelog']
+
+  try {
+    // Read package.json
+    const pkgPath = path.join(rootPath, 'package.json')
+    const pkg = await fs.readJSON(pkgPath)
+    const newVersion = versionBump(pkg.version, releaseType)
+
+    console.log(`📦 Publishing ${pkg.name} v${pkg.version} → v${newVersion}`)
+    console.log(`📁 Source: ${publishArgs.src}/`)
+
+    // Check if source directory exists
+    if (!await fs.pathExists(srcDir)) {
+      throw new Error(`Source directory "${publishArgs.src}" does not exist. Run "itty build" first.`)
+    }
+
+    // Clean and create temp directory
+    console.log(`🧹 Preparing ${publishArgs.dest}/`)
+    await fs.emptyDir(tempDir)
+    await fs.ensureDir(tempDir)
+
+    // Copy source files to temp directory
+    console.log(`📋 Copying ${publishArgs.src}/ to ${path.relative(rootPath, tempDir)}/`)
+    
+    const filter = (src) => {
+      // Always exclude node_modules
+      if (src.includes('node_modules')) return false
+      
+      // For root publishing, exclude additional files
+      if (isRootPublish) {
+        const relativePath = path.relative(srcDir, src)
+        return !relativePath.startsWith('.git') && 
+               !relativePath.includes('.DS_Store') &&
+               !relativePath.includes('coverage/') &&
+               !relativePath.includes('.nyc_output/')
+      }
+      
+      return true
+    }
+    
+    await fs.copy(srcDir, tempDir, { filter })
+
+    // Copy root files that should be included in the package (only for non-root publishing)
+    if (!isRootPublish) {
+      const rootFiles = [
+        'README.md',  // Always copy README
+        '.npmrc'      // Always copy .npmrc if it exists
+      ]
+      
+      // Add optional files based on flags
+      if (!noLicense) rootFiles.push('LICENSE')
+      if (!noChangelog) rootFiles.push('CHANGELOG.md')
+      
+      for (const file of rootFiles) {
+        const srcFile = path.join(rootPath, file)
+        const destFile = path.join(tempDir, file)
+        
+        if (await fs.pathExists(srcFile)) {
+          console.log(`📄 Copying ${file}`)
+          await fs.copy(srcFile, destFile)
+        }
+      }
+    }
+
+    // Update package.json in temp directory with transformed paths
+    const updatedPkg = isRootPublish 
+      ? { ...pkg, version: newVersion }  // No path transformation for root publishing
+      : transformPackageExports({ ...pkg, version: newVersion }, publishArgs.src)
+    const tempPkgPath = path.join(tempDir, 'package.json')
+    
+    const transformMessage = isRootPublish ? '' : ' (transforming paths)'
+    console.log(`📝 Updating package.json to v${newVersion}${transformMessage}`)
+    await fs.writeJSON(tempPkgPath, updatedPkg, { spaces: 2 })
+
+    if (dryRun) {
+      console.log('🧪 Dry run - skipping publish')
+    } else {
+      // Publish from temp directory
+      console.log(`🚀 Publishing to npm...`)
+      
+      const publishCmd = [
+        'npm publish',
+        publicAccess ? '--access=public' : '',
+        SEMVER_TYPES.includes(releaseType) ? '' : `--tag=${releaseType}`
+      ].filter(Boolean).join(' ')
+
+      console.log(`Running: ${publishCmd}`)
+      await runCommand(publishCmd, tempDir)
+      
+      // Update root package.json
+      console.log(`📝 Updating root package.json`)
+      await fs.writeJSON(pkgPath, updatedPkg, { spaces: 2 })
+    }
+
+    // Git operations
+    if (!noGit && !dryRun) {
+      if (shouldPush || shouldTag) {
+        console.log(`📋 Committing changes...`)
+        await runCommand('git add .', rootPath)
+        await runCommand(`git commit -m "released v${newVersion}"`, rootPath)
+      }
+
+      if (shouldTag) {
+        console.log(`🏷️  Creating git tag v${newVersion}`)
+        await runCommand(`git tag -a v${newVersion} -m "Release v${newVersion}"`, rootPath)
+      }
+
+      if (shouldPush) {
+        console.log(`📤 Pushing to remote...`)
+        await runCommand('git push', rootPath)
+        
+        if (shouldTag) {
+          console.log(`📤 Pushing tags...`)
+          await runCommand('git push --tags', rootPath)
+        }
+      }
+    }
+
+    // Cleanup
+    if (!noCleanup) {
+      console.log(`🧹 Cleaning up ${publishArgs.dest}/`)
+      await fs.remove(tempDir)
+    }
+
+    console.log(`✅ Successfully published ${pkg.name}@${newVersion}`)
+    
+  } catch (error) {
+    console.error(`❌ Publish failed: ${error.message}`)
+    
+    // Cleanup on error
+    if (await fs.pathExists(tempDir) && !noCleanup) {
+      await fs.remove(tempDir)
+    }
+    
+    throw error
+  }
+}

package/lib/configs/createConfig.mjs

@@ -0,0 +1,101 @@
+import typescriptEslint from '@typescript-eslint/eslint-plugin'
+import tsParser from '@typescript-eslint/parser'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import js from '@eslint/js'
+import { FlatCompat } from '@eslint/eslintrc'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+})
+
+// Base configuration that all itty projects should use
+const baseConfig = [...compat.extends(
+    'eslint:recommended',
+    'plugin:@typescript-eslint/eslint-recommended',
+    'plugin:@typescript-eslint/recommended',
+), {
+    plugins: {
+        '@typescript-eslint': typescriptEslint,
+    },
+
+    languageOptions: {
+        parser: tsParser,
+    },
+
+    rules: {
+        '@typescript-eslint/no-empty-function': 'off',
+        '@typescript-eslint/no-explicit-any': 'off',
+        '@typescript-eslint/ban-types': 'off',
+        '@typescript-eslint/ban-ts-comment': 'off',
+        'linebreak-style': ['error', 'unix'],
+        'prefer-const': 'off',
+
+        quotes: ['error', 'single', {
+            allowTemplateLiterals: true,
+        }],
+
+        semi: ['error', 'never'],
+    },
+}]
+
+/**
+ * Create an ESLint config by extending the base itty configuration
+ * @param {Object} overrides - Configuration overrides
+ * @param {Object} overrides.rules - Additional or modified rules
+ * @param {Object} overrides.languageOptions - Language options to merge
+ * @param {Array} overrides.plugins - Additional plugins
+ * @param {Array} overrides.ignores - Files/patterns to ignore
+ * @returns {Array} ESLint flat config
+ */
+export function createConfig(overrides = {}) {
+  const config = [...baseConfig]
+  
+  if (overrides.rules || overrides.languageOptions || overrides.plugins || overrides.ignores) {
+    // Create a new config object that extends the base
+    const extendedConfig = {
+      ...config[config.length - 1], // Take the last config object from base
+    }
+    
+    // Merge rules
+    if (overrides.rules) {
+      extendedConfig.rules = {
+        ...extendedConfig.rules,
+        ...overrides.rules
+      }
+    }
+    
+    // Merge language options
+    if (overrides.languageOptions) {
+      extendedConfig.languageOptions = {
+        ...extendedConfig.languageOptions,
+        ...overrides.languageOptions
+      }
+    }
+    
+    // Merge plugins
+    if (overrides.plugins) {
+      extendedConfig.plugins = {
+        ...extendedConfig.plugins,
+        ...overrides.plugins
+      }
+    }
+    
+    // Add ignores
+    if (overrides.ignores) {
+      extendedConfig.ignores = overrides.ignores
+    }
+    
+    // Replace the last config in the array
+    config[config.length - 1] = extendedConfig
+  }
+  
+  return config
+}
+
+// Export the base config as default for direct use
+export default baseConfig

package/lib/configs/eslint.config.mjs

@@ -0,0 +1,3 @@
+import baseConfig from './createConfig.mjs'
+
+export default baseConfig

package/lib/configs/eslint.config.template.mjs

@@ -0,0 +1,30 @@
+// Template for extending the built-in itty-packager ESLint config
+// Copy this to your project root as 'eslint.config.mjs' and customize as needed
+
+import { createConfig } from 'itty-packager/lib/configs/createConfig.mjs'
+
+export default createConfig({
+  // Add custom rules specific to your project
+  rules: {
+    // Example: Allow console statements
+    // 'no-console': 'off',
+    
+    // Example: Require spaces around object braces
+    // 'object-curly-spacing': ['error', 'always'],
+    
+    // Example: Prefer template literals over string concatenation
+    // 'prefer-template': 'error',
+  },
+  
+  // Add project-specific ignores (in addition to defaults)
+  ignores: [
+    // 'test-fixtures/**',
+    // 'docs/**',
+  ]
+})
+
+// Available options for createConfig():
+// - rules: Object with ESLint rule overrides
+// - languageOptions: Parser and environment settings  
+// - plugins: Additional ESLint plugins
+// - ignores: Array of file patterns to ignore

package/package.json

@@ -1,26 +1,47 @@
 {
   "name": "itty-packager",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Universal build tool for itty libraries",
   "type": "module",
   "bin": {
     "itty": "./bin/itty.js"
   },
   "scripts": {
-    "dev": "node bin/itty-packager.js",
-    "test": "echo 'No tests yet'"
+    "lint": "bun bin/itty.js lint",
+    "test": "echo 'No tests yet'",
+    "release:dry": "bun bin/itty.js publish --patch --tag --dry-run --src=. --no-license --no-changelog",
+    "release": "bun bin/itty.js publish --patch --tag --push --src=. --no-license --no-changelog",
+    "release:minor": "bun bin/itty.js publish --minor --tag --push --src=. --no-license --no-changelog",
+    "release:major": "bun bin/itty.js publish --major --tag --push --src=. --no-license --no-changelog"
   },
   "keywords": [
     "build",
     "rollup",
     "typescript",
+    "eslint",
+    "publish",
+    "cli",
+    "tool",
     "itty"
   ],
   "author": "Kevin R. Whitley <krwhitley@gmail.com>",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhitley/itty-packager.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kwhitley/itty-packager/issues"
+  },
+  "homepage": "https://github.com/kwhitley/itty-packager#readme",
   "dependencies": {
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.17.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
+    "eslint": "^9.17.0",
     "fs-extra": "^11.2.0",
     "globby": "^14.1.0",
     "rimraf": "^6.0.1",
@@ -30,4 +51,4 @@
     "tslib": "^2.8.1",
     "typescript": "^5.7.2"
   }
-}
+}