@a35hie/ts-pkg 0.1.0

package/src/main.ts

@@ -0,0 +1,66 @@
+import type {
+  PackageConfig,
+  StandardPackageJson,
+  ScriptPreset,
+  DependencyInput,
+  ConditionalConfig,
+  License,
+} from './schemas/package'
+import {
+  createPackageJson,
+  writePackageJson,
+  type GenerateOptions,
+} from './generator/createPackageJson'
+
+export function definePackageConfig(config: PackageConfig): PackageConfig {
+  return config
+}
+
+// Run CLI if executed directly
+async function main() {
+  const configPath = process.argv[2] ?? 'package.config.ts'
+  const outputPath = process.argv[3] ?? 'package.json'
+
+  try {
+    const configModule = await import(Bun.pathToFileURL(configPath).href)
+    const config: PackageConfig = configModule.default ?? configModule
+
+    await writePackageJson(config, { outputPath })
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ERR_MODULE_NOT_FOUND') {
+      console.error(`❌ Config file not found: ${configPath}`)
+      console.error('\nCreate a package.config.ts file with:')
+      console.error(`
+import { definePackageConfig } from './src/main'
+
+export default definePackageConfig({
+  name: 'my-package',
+  version: '1.0.0',
+  scriptPresets: ['typescript', 'testing'],
+  dependencies: ['lodash', 'zod'],
+  devDependencies: ['typescript', 'vitest'],
+})
+`)
+      process.exit(1)
+    }
+    throw error
+  }
+}
+
+// Export everything
+export {
+  createPackageJson,
+  writePackageJson,
+  type PackageConfig,
+  type StandardPackageJson,
+  type ScriptPreset,
+  type DependencyInput,
+  type ConditionalConfig,
+  type GenerateOptions,
+  type License,
+}
+
+// Run if main module
+if (import.meta.main) {
+  main()
+}

package/src/presets/scripts.ts

@@ -0,0 +1,59 @@
+import type { ScriptPreset } from '../schemas/package'
+
+type ScriptDefinitions = Record<string, string>
+
+const scriptPresets: Record<ScriptPreset, ScriptDefinitions> = {
+  typescript: {
+    build: 'tsc',
+    'build:watch': 'tsc --watch',
+    typecheck: 'tsc --noEmit',
+  },
+
+  react: {
+    dev: 'vite',
+    build: 'vite build',
+    preview: 'vite preview',
+  },
+
+  node: {
+    start: 'node dist/index.js',
+    dev: 'tsx watch src/index.ts',
+    build: 'tsup src/index.ts --format esm,cjs --dts',
+  },
+
+  testing: {
+    test: 'vitest',
+    'test:watch': 'vitest watch',
+    'test:coverage': 'vitest --coverage',
+  },
+
+  prettier: {
+    format: 'prettier --write .',
+    'format:check': 'prettier --check .',
+  },
+
+  eslint: {
+    lint: 'eslint .',
+    'lint:fix': 'eslint . --fix',
+  },
+}
+
+export function getPresetScripts(presets: ScriptPreset[]): ScriptDefinitions {
+  const merged: ScriptDefinitions = {}
+
+  for (const preset of presets) {
+    const scripts = scriptPresets[preset]
+    if (scripts) {
+      Object.assign(merged, scripts)
+    }
+  }
+
+  return merged
+}
+
+export function mergeScripts(
+  presetScripts: ScriptDefinitions,
+  customScripts?: ScriptDefinitions
+): ScriptDefinitions {
+  return { ...presetScripts, ...customScripts }
+}

package/src/resolvers/dependencies.ts

@@ -0,0 +1,107 @@
+import type { DependencyInput } from '../schemas/package'
+
+interface NpmPackageInfo {
+  'dist-tags': {
+    latest: string
+    [tag: string]: string
+  }
+  versions: Record<string, unknown>
+}
+
+// Parse dependency input: 'lodash' | 'lodash@^4' | { lodash: '^4.0.0' }
+function parseDependency(dep: DependencyInput): {
+  name: string
+  version?: string
+} {
+  if (typeof dep === 'string') {
+    const atIndex = dep.lastIndexOf('@')
+    if (atIndex > 0) {
+      return {
+        name: dep.slice(0, atIndex),
+        version: dep.slice(atIndex + 1),
+      }
+    }
+    return { name: dep }
+  }
+
+  // Object form: { lodash: '^4.0.0' }
+  const [name, version] = Object.entries(dep)[0]!
+  return { name, version }
+}
+
+// Fetch latest version from npm registry
+async function fetchLatestVersion(packageName: string): Promise<string> {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}`
+
+  const response = await fetch(url, {
+    headers: { Accept: 'application/json' },
+  })
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${packageName}: ${response.statusText}`)
+  }
+
+  const data = (await response.json()) as NpmPackageInfo
+  return data['dist-tags'].latest
+}
+
+// Resolve a single dependency to name: version pair
+async function resolveDependency(
+  dep: DependencyInput
+): Promise<[string, string]> {
+  const { name, version } = parseDependency(dep)
+
+  if (version) {
+    return [name, version]
+  }
+
+  // Auto-resolve latest version with ^ prefix
+  const latestVersion = await fetchLatestVersion(name)
+  return [name, `^${latestVersion}`]
+}
+
+// Resolve all dependencies in parallel with batching
+export async function resolveDependencies(
+  deps: DependencyInput[] | undefined
+): Promise<Record<string, string>> {
+  if (!deps || deps.length === 0) {
+    return {}
+  }
+
+  const results = await Promise.all(deps.map(resolveDependency))
+
+  return Object.fromEntries(results)
+}
+
+// Cache for resolved versions (persists during single run)
+const versionCache = new Map<string, string>()
+
+export async function resolveDependenciesCached(
+  deps: DependencyInput[] | undefined
+): Promise<Record<string, string>> {
+  if (!deps || deps.length === 0) {
+    return {}
+  }
+
+  const results: [string, string][] = []
+
+  for (const dep of deps) {
+    const { name, version } = parseDependency(dep)
+
+    if (version) {
+      results.push([name, version])
+      continue
+    }
+
+    // Check cache first
+    let resolvedVersion = versionCache.get(name)
+    if (!resolvedVersion) {
+      resolvedVersion = `^${await fetchLatestVersion(name)}`
+      versionCache.set(name, resolvedVersion)
+    }
+
+    results.push([name, resolvedVersion])
+  }
+
+  return Object.fromEntries(results)
+}

package/src/schemas/package.ts

@@ -0,0 +1,122 @@
+// Common SPDX license identifiers
+export type License =
+  | 'MIT'
+  | 'Apache-2.0'
+  | 'GPL-2.0-only'
+  | 'GPL-2.0-or-later'
+  | 'GPL-3.0-only'
+  | 'GPL-3.0-or-later'
+  | 'LGPL-2.1-only'
+  | 'LGPL-2.1-or-later'
+  | 'LGPL-3.0-only'
+  | 'LGPL-3.0-or-later'
+  | 'BSD-2-Clause'
+  | 'BSD-3-Clause'
+  | 'ISC'
+  | 'MPL-2.0'
+  | 'AGPL-3.0-only'
+  | 'AGPL-3.0-or-later'
+  | 'Unlicense'
+  | 'WTFPL'
+  | 'CC0-1.0'
+  | 'CC-BY-4.0'
+  | 'CC-BY-SA-4.0'
+  | 'Zlib'
+  | 'BSL-1.0'
+  | 'EPL-2.0'
+  | 'EUPL-1.2'
+  | 'CDDL-1.0'
+  | 'Artistic-2.0'
+  | 'OSL-3.0'
+  | 'AFL-3.0'
+  | 'LPPL-1.3c'
+  | (string & {}) // Allow custom licenses while preserving autocomplete
+
+// Standard package.json fields
+export interface StandardPackageJson {
+  name: string
+  version?: string
+  description?: string
+  keywords?: string[]
+  homepage?: string
+  bugs?: string | { url?: string; email?: string }
+  license?: License
+  author?: string | { name: string; email?: string; url?: string }
+  contributors?: (string | { name: string; email?: string; url?: string })[]
+  repository?: string | { type: string; url: string; directory?: string }
+  main?: string
+  module?: string
+  types?: string
+  exports?: Record<
+    string,
+    string | { import?: string; require?: string; types?: string }
+  >
+  bin?: string | Record<string, string>
+  files?: string[]
+  scripts?: Record<string, string>
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+  optionalDependencies?: Record<string, string>
+  engines?: Record<string, string>
+  os?: string[]
+  cpu?: string[]
+  private?: boolean
+  publishConfig?: Record<string, unknown>
+  workspaces?: string[]
+  type?: 'module' | 'commonjs'
+}
+
+// Script preset names
+export type ScriptPreset =
+  | 'typescript'
+  | 'react'
+  | 'node'
+  | 'testing'
+  | 'prettier'
+  | 'eslint'
+
+// Dependency can be: 'lodash' | 'lodash@^4' | { lodash: '^4.0.0' }
+export type DependencyInput = string | Record<string, string>
+
+// Conditional config block
+export interface ConditionalConfig {
+  when: {
+    env?: string
+    platform?: NodeJS.Platform
+    nodeVersion?: string
+    ci?: boolean
+  }
+  set: Partial<StandardPackageJson>
+}
+
+// Magical package.json config with extra features
+export interface PackageConfig extends Omit<
+  StandardPackageJson,
+  'scripts' | 'dependencies' | 'devDependencies' | 'peerDependencies'
+> {
+  // Extends another config
+  extends?: string | PackageConfig
+
+  // Script presets: auto-generate common scripts
+  scriptPresets?: ScriptPreset[]
+  scripts?: Record<string, string>
+
+  // Magical dependency inputs (auto-resolve versions)
+  dependencies?: DependencyInput[]
+  devDependencies?: DependencyInput[]
+  peerDependencies?: DependencyInput[]
+
+  // Conditional configuration
+  conditions?: ConditionalConfig[]
+
+  // Auto-infer fields
+  autoInfer?: {
+    version?: boolean // from git tags
+    repository?: boolean // from git remote
+    author?: boolean // from git config
+  }
+}
+
+// Re-export for backwards compatibility
+export type PackageJson = PackageConfig

package/src/utils/conditions.ts

@@ -0,0 +1,67 @@
+import type { ConditionalConfig, StandardPackageJson } from '../schemas/package'
+import { deepMerge } from './merge'
+
+interface ConditionContext {
+  env: string
+  platform: NodeJS.Platform
+  nodeVersion: string
+  ci: boolean
+}
+
+function getContext(): ConditionContext {
+  return {
+    env: process.env.NODE_ENV ?? 'development',
+    platform: process.platform,
+    nodeVersion: process.version,
+    ci: process.env.CI === 'true' || process.env.CI === '1',
+  }
+}
+
+function evaluateCondition(
+  when: ConditionalConfig['when'],
+  context: ConditionContext
+): boolean {
+  if (when.env !== undefined && context.env !== when.env) {
+    return false
+  }
+
+  if (when.platform !== undefined && context.platform !== when.platform) {
+    return false
+  }
+
+  if (when.ci !== undefined && context.ci !== when.ci) {
+    return false
+  }
+
+  if (when.nodeVersion !== undefined) {
+    // Simple semver check (starts with)
+    if (!context.nodeVersion.startsWith(when.nodeVersion)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export function applyConditions(
+  baseConfig: Partial<StandardPackageJson>,
+  conditions: ConditionalConfig[] | undefined
+): Partial<StandardPackageJson> {
+  if (!conditions || conditions.length === 0) {
+    return baseConfig
+  }
+
+  const context = getContext()
+  let result = { ...baseConfig }
+
+  for (const condition of conditions) {
+    if (evaluateCondition(condition.when, context)) {
+      result = deepMerge(
+        result,
+        condition.set as Record<string, unknown>
+      ) as Partial<StandardPackageJson>
+    }
+  }
+
+  return result
+}

package/src/utils/merge.ts

@@ -0,0 +1,91 @@
+import type { PackageConfig } from '../schemas/package'
+
+// Deep merge two objects, with source overriding target
+export function deepMerge<T extends Record<string, unknown>>(
+  target: T,
+  source: Partial<T>
+): T {
+  const result = { ...target }
+
+  for (const key of Object.keys(source) as (keyof T)[]) {
+    const sourceValue = source[key]
+    const targetValue = target[key]
+
+    if (sourceValue === undefined) continue
+
+    if (
+      typeof sourceValue === 'object' &&
+      sourceValue !== null &&
+      !Array.isArray(sourceValue) &&
+      typeof targetValue === 'object' &&
+      targetValue !== null &&
+      !Array.isArray(targetValue)
+    ) {
+      result[key] = deepMerge(
+        targetValue as Record<string, unknown>,
+        sourceValue as Record<string, unknown>
+      ) as T[keyof T]
+    } else {
+      result[key] = sourceValue as T[keyof T]
+    }
+  }
+
+  return result
+}
+
+// Merge arrays (for dependencies)
+export function mergeArrays<T>(
+  target: T[] | undefined,
+  source: T[] | undefined
+): T[] {
+  return [...(target ?? []), ...(source ?? [])]
+}
+
+// Resolve extends chain
+export async function resolveExtends(
+  config: PackageConfig
+): Promise<PackageConfig> {
+  if (!config.extends) {
+    return config
+  }
+
+  let baseConfig: PackageConfig
+
+  if (typeof config.extends === 'string') {
+    // Import from file path
+    const imported = await import(config.extends)
+    baseConfig = imported.default ?? imported
+  } else {
+    baseConfig = config.extends
+  }
+
+  // Recursively resolve base config's extends
+  baseConfig = await resolveExtends(baseConfig)
+
+  // Merge base into current (current overrides base)
+  const { extends: _, ...currentWithoutExtends } = config
+
+  return {
+    ...baseConfig,
+    ...currentWithoutExtends,
+    // Merge arrays for dependencies
+    dependencies: mergeArrays(
+      baseConfig.dependencies,
+      currentWithoutExtends.dependencies
+    ),
+    devDependencies: mergeArrays(
+      baseConfig.devDependencies,
+      currentWithoutExtends.devDependencies
+    ),
+    peerDependencies: mergeArrays(
+      baseConfig.peerDependencies,
+      currentWithoutExtends.peerDependencies
+    ),
+    // Merge objects for scripts
+    scripts: { ...baseConfig.scripts, ...currentWithoutExtends.scripts },
+    scriptPresets: [
+      ...(baseConfig.scriptPresets ?? []),
+      ...(currentWithoutExtends.scriptPresets ?? []),
+    ],
+  }
+}

package/ts-pkg-config.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="GENERAL_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}