@shazhou/proman-core 0.9.0

package/src/commands/init.ts

@@ -0,0 +1,290 @@
+import { execSync } from 'node:child_process'
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs'
+import { basename, join, resolve } from 'node:path'
+
+export type InitOptions = {
+  targetDir: string
+}
+
+function jsonStringify(obj: unknown): string {
+  return JSON.stringify(obj, null, 2)
+}
+
+/**
+ * Sanitize a directory name into a valid npm package name segment.
+ *
+ * Rules applied (per https://github.com/npm/validate-npm-package-name):
+ * - lowercase only
+ * - strip characters not in `[a-z0-9._-]` (replaces with hyphens)
+ * - strip leading `.`, `_`, or `-`
+ * - collapse consecutive hyphens
+ * - enforce 214-character npm limit
+ * - fall back to `'my-project'` if nothing remains
+ */
+function toPackageName(dirName: string): string {
+  return (
+    dirName
+      .toLowerCase()
+      .replace(/[^a-z0-9._-]/g, '-') // replace invalid chars
+      .replace(/^[._-]+/, '') // strip leading dots/hyphens/underscores
+      .replace(/-+/g, '-') // collapse consecutive hyphens
+      .slice(0, 214) || // npm name length limit
+    'my-project'
+  ) // fallback if everything was stripped
+}
+
+export async function init(opts: InitOptions): Promise<void> {
+  const targetDir = resolve(opts.targetDir)
+  const projectName = toPackageName(basename(targetDir))
+
+  // Check if directory is empty
+  if (existsSync(targetDir)) {
+    const entries = readdirSync(targetDir)
+    if (entries.length > 0) {
+      throw new Error(`Directory is not empty: ${targetDir}`)
+    }
+  } else {
+    mkdirSync(targetDir, { recursive: true })
+  }
+
+  // Create root files
+  createRootPackageJson(targetDir, projectName)
+  createPromanYaml(targetDir, projectName)
+  createPnpmWorkspace(targetDir)
+  createBiomeJson(targetDir)
+  createTsConfig(targetDir)
+  createGitignore(targetDir)
+
+  // Create packages
+  createCorePackage(targetDir, projectName)
+  createCliPackage(targetDir, projectName)
+
+  // Format all JSON files with biome
+  try {
+    execSync('pnpm exec biome format --write .', { cwd: targetDir, stdio: 'ignore' })
+  } catch {
+    // Ignore biome formatting errors during init - user can run format later
+  }
+
+  // Print post-init message
+  console.log(`✓ Created monorepo in ${targetDir}`)
+  console.log('')
+  console.log('Next steps:')
+  if (targetDir !== process.cwd()) {
+    console.log(`  cd ${projectName}`)
+  }
+  console.log('  pnpm install')
+  console.log('  proman build')
+}
+
+function createRootPackageJson(targetDir: string, projectName: string): void {
+  const content = {
+    name: projectName,
+    private: true,
+    type: 'module',
+    scripts: {
+      build: 'proman build',
+      test: 'proman test',
+      check: 'proman check',
+      format: 'proman format',
+    },
+    devDependencies: {
+      '@biomejs/biome': '^2.4.16',
+      '@shazhou/proman': '^0.7.0',
+      '@types/node': '^22.0.0',
+      typescript: '^5.9.3',
+      vitest: '^4.1.8',
+    },
+  }
+  writeFileSync(join(targetDir, 'package.json'), `${jsonStringify(content)}\n`)
+}
+
+function createPromanYaml(targetDir: string, projectName: string): void {
+  const content = `packages:
+  - name: '@${projectName}/core'
+    path: packages/core
+    type: lib
+  - name: '@${projectName}/cli'
+    path: packages/cli
+    type: cli
+`
+  writeFileSync(join(targetDir, 'proman.yaml'), content)
+}
+
+function createPnpmWorkspace(targetDir: string): void {
+  const content = `packages:
+  - 'packages/*'
+
+allowBuilds:
+  esbuild: true
+`
+  writeFileSync(join(targetDir, 'pnpm-workspace.yaml'), content)
+}
+
+function createBiomeJson(targetDir: string): void {
+  const content = {
+    $schema: 'https://biomejs.dev/schemas/2.4.16/schema.json',
+    assist: { actions: { source: { organizeImports: 'on' } } },
+    linter: {
+      enabled: true,
+      rules: { recommended: true },
+    },
+    formatter: {
+      enabled: true,
+      indentStyle: 'space',
+      indentWidth: 2,
+      lineWidth: 100,
+    },
+    javascript: {
+      formatter: {
+        quoteStyle: 'single',
+        semicolons: 'asNeeded',
+        trailingCommas: 'all',
+      },
+    },
+    files: {
+      includes: ['**', '!**/dist', '!**/node_modules', '!**/tests/fixtures', '!.worktrees'],
+    },
+  }
+  writeFileSync(join(targetDir, 'biome.json'), `${jsonStringify(content)}\n`)
+}
+
+function createTsConfig(targetDir: string): void {
+  const content = {
+    compilerOptions: {
+      target: 'ESNext',
+      module: 'ESNext',
+      moduleResolution: 'bundler',
+      strict: true,
+      skipLibCheck: true,
+      verbatimModuleSyntax: true,
+      esModuleInterop: true,
+      resolveJsonModule: true,
+      types: ['node'],
+      lib: ['ESNext'],
+    },
+    references: [{ path: './packages/core' }, { path: './packages/cli' }],
+  }
+  writeFileSync(join(targetDir, 'tsconfig.json'), `${jsonStringify(content)}\n`)
+}
+
+function createGitignore(targetDir: string): void {
+  const content = `node_modules
+dist
+.proman
+*.tsbuildinfo
+`
+  writeFileSync(join(targetDir, '.gitignore'), content)
+}
+
+function createCorePackage(targetDir: string, projectName: string): void {
+  const pkgDir = join(targetDir, 'packages', 'core')
+  mkdirSync(join(pkgDir, 'src'), { recursive: true })
+
+  // package.json
+  const packageJson = {
+    name: `@${projectName}/core`,
+    version: '0.0.1',
+    type: 'module',
+    exports: {
+      '.': {
+        types: './dist/index.d.ts',
+        default: './dist/index.js',
+      },
+    },
+    files: ['dist'],
+    scripts: {
+      build: 'tsc --build',
+    },
+  }
+  writeFileSync(join(pkgDir, 'package.json'), `${jsonStringify(packageJson)}\n`)
+
+  // tsconfig.json
+  const tsConfig = {
+    extends: '../../tsconfig.json',
+    compilerOptions: {
+      composite: true,
+      outDir: 'dist',
+      rootDir: 'src',
+      noEmit: false,
+      declaration: true,
+    },
+    include: ['src/**/*'],
+  }
+  writeFileSync(join(pkgDir, 'tsconfig.json'), `${jsonStringify(tsConfig)}\n`)
+
+  // src/index.ts
+  const indexTs = `export function hello(): string {
+  return 'hello'
+}
+`
+  writeFileSync(join(pkgDir, 'src', 'index.ts'), indexTs)
+
+  // src/index.test.ts
+  const testTs = `import { describe, expect, test } from 'vitest'
+import { hello } from './index.js'
+
+describe('hello', () => {
+  test('returns hello', () => {
+    expect(hello()).toBe('hello')
+  })
+})
+`
+  writeFileSync(join(pkgDir, 'src', 'index.test.ts'), testTs)
+}
+
+function createCliPackage(targetDir: string, projectName: string): void {
+  const pkgDir = join(targetDir, 'packages', 'cli')
+  mkdirSync(join(pkgDir, 'src'), { recursive: true })
+
+  // package.json
+  const packageJson = {
+    name: `@${projectName}/cli`,
+    version: '0.0.1',
+    type: 'module',
+    bin: {
+      [projectName]: 'dist/cli.js',
+    },
+    files: ['dist'],
+    scripts: {
+      build: 'tsc --build',
+    },
+    dependencies: {
+      [`@${projectName}/core`]: 'workspace:*',
+    },
+  }
+  writeFileSync(join(pkgDir, 'package.json'), `${jsonStringify(packageJson)}\n`)
+
+  // tsconfig.json
+  const tsConfig = {
+    extends: '../../tsconfig.json',
+    compilerOptions: {
+      composite: true,
+      outDir: 'dist',
+      rootDir: 'src',
+      noEmit: false,
+    },
+    include: ['src/**/*'],
+    references: [{ path: '../core' }],
+  }
+  writeFileSync(join(pkgDir, 'tsconfig.json'), `${jsonStringify(tsConfig)}\n`)
+
+  // src/cli.ts
+  const cliTs = `#!/usr/bin/env node
+import { hello } from '@${projectName}/core'
+
+console.log(hello())
+`
+  writeFileSync(join(pkgDir, 'src', 'cli.ts'), cliTs)
+
+  // src/cli.test.ts
+  const testTs = `import { describe, expect, test } from 'vitest'
+
+describe('cli', () => {
+  test('placeholder test', () => {
+    expect(true).toBe(true)
+  })
+})
+`
+  writeFileSync(join(pkgDir, 'src', 'cli.test.ts'), testTs)
+}

package/src/commands/link.ts

@@ -0,0 +1,195 @@
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { defaultSpawn, runOrThrow, type SpawnFn } from '../utils/npm.js'
+
+export type LinkCommandOptions = {
+  cwd: string
+  packageName?: string
+  spawn?: SpawnFn
+}
+
+function readPackageJson(cwd: string): {
+  name?: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+} {
+  const pkgPath = join(cwd, 'package.json')
+  if (!existsSync(pkgPath)) {
+    throw new Error(`Missing package.json in ${cwd}`)
+  }
+  const json = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+
+  // Runtime validation: ensure parsed value is an object (not array, primitive, or null)
+  if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+    throw new Error(`Invalid package.json at ${pkgPath}: expected a JSON object`)
+  }
+
+  return json
+}
+
+function hasDistFolder(cwd: string): boolean {
+  const distPath = join(cwd, 'dist')
+  return existsSync(distPath)
+}
+
+/**
+ * Link a package globally (provider mode) or link from global registry (consumer mode)
+ */
+export async function link(opts: LinkCommandOptions): Promise<void> {
+  const spawn = opts.spawn ?? defaultSpawn
+  const cwd = resolve(opts.cwd)
+
+  // Consumer mode: link specific package from global registry
+  if (opts.packageName) {
+    const pkg = readPackageJson(cwd)
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies }
+    if (!allDeps[opts.packageName]) {
+      throw new Error(
+        `Package "${opts.packageName}" not found in dependencies or devDependencies of ${cwd}`,
+      )
+    }
+
+    await runOrThrow(spawn, ['pnpm', 'link', '--global', opts.packageName], cwd)
+    console.log(`✓ Linked ${opts.packageName} from global registry`)
+    return
+  }
+
+  // Provider mode: link current package globally
+  const pkg = readPackageJson(cwd)
+  if (!pkg.name) {
+    throw new Error(`package.json in ${cwd} is missing a "name" field`)
+  }
+
+  if (!hasDistFolder(cwd)) {
+    throw new Error(`No dist/ folder in ${cwd}. Run \`proman build\` first.`)
+  }
+
+  await runOrThrow(spawn, ['pnpm', 'link', '--global'], cwd)
+  console.log(`✓ Linked ${pkg.name} globally`)
+}
+
+/**
+ * Show currently linked packages
+ */
+export async function linkStatus(opts: Omit<LinkCommandOptions, 'packageName'>): Promise<string> {
+  const cwd = resolve(opts.cwd)
+  const nodeModulesDir = join(cwd, 'node_modules')
+
+  if (!existsSync(nodeModulesDir)) {
+    return 'No linked packages found'
+  }
+
+  const linkedPackages: { name: string; target: string }[] = []
+
+  // Scan node_modules for symlinks
+  function scanDir(dir: string, prefix = ''): void {
+    if (!existsSync(dir)) return
+
+    for (const entry of readdirSync(dir)) {
+      const fullPath = join(dir, entry)
+      const stat = lstatSync(fullPath)
+
+      // Check if it's a symlink
+      if (stat.isSymbolicLink()) {
+        const target = readlinkSync(fullPath)
+        const resolvedTarget = resolve(dir, target)
+        const pkgJsonPath = join(fullPath, 'package.json')
+
+        if (existsSync(pkgJsonPath)) {
+          try {
+            const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'))
+            const name = pkgJson.name || `${prefix}${entry}`
+            linkedPackages.push({ name, target: resolvedTarget })
+          } catch {
+            // Invalid package.json, skip
+          }
+        }
+      } else if (stat.isDirectory() && entry.startsWith('@')) {
+        // Scan scoped packages
+        scanDir(fullPath, `${entry}/`)
+      }
+    }
+  }
+
+  scanDir(nodeModulesDir)
+
+  if (linkedPackages.length === 0) {
+    return 'No linked packages found'
+  }
+
+  const lines = ['Linked packages:']
+  for (const { name, target } of linkedPackages) {
+    lines.push(`• ${name} → ${target}`)
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Unlink packages (all or specific)
+ */
+export async function unlink(opts: LinkCommandOptions): Promise<void> {
+  const spawn = opts.spawn ?? defaultSpawn
+  const cwd = resolve(opts.cwd)
+
+  // Unlink specific package
+  if (opts.packageName) {
+    await runOrThrow(spawn, ['pnpm', 'unlink', opts.packageName], cwd)
+    await runOrThrow(spawn, ['pnpm', 'install', opts.packageName], cwd)
+    console.log(`✓ Unlinked ${opts.packageName} and restored from registry`)
+    return
+  }
+
+  // Unlink all packages
+  const nodeModulesDir = join(cwd, 'node_modules')
+
+  if (!existsSync(nodeModulesDir)) {
+    console.log('No linked packages to unlink')
+    return
+  }
+
+  const linkedPackages: string[] = []
+
+  // Find all symlinked packages
+  function scanDir(dir: string): void {
+    if (!existsSync(dir)) return
+
+    for (const entry of readdirSync(dir)) {
+      const fullPath = join(dir, entry)
+      const stat = lstatSync(fullPath)
+
+      if (stat.isSymbolicLink()) {
+        const pkgJsonPath = join(fullPath, 'package.json')
+        if (existsSync(pkgJsonPath)) {
+          try {
+            const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'))
+            if (pkgJson.name) {
+              linkedPackages.push(pkgJson.name)
+            }
+          } catch {
+            // Invalid package.json, skip
+          }
+        }
+      } else if (stat.isDirectory() && entry.startsWith('@')) {
+        scanDir(fullPath)
+      }
+    }
+  }
+
+  scanDir(nodeModulesDir)
+
+  if (linkedPackages.length === 0) {
+    console.log('No linked packages to unlink')
+    return
+  }
+
+  // Unlink each package
+  for (const pkgName of linkedPackages) {
+    await runOrThrow(spawn, ['pnpm', 'unlink', pkgName], cwd)
+  }
+
+  // Restore all packages
+  await runOrThrow(spawn, ['pnpm', 'install'], cwd)
+
+  console.log(`✓ Unlinked ${linkedPackages.length} package(s) and restored from registry`)
+}

package/src/commands/publish.ts

@@ -0,0 +1,168 @@
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { loadConfig } from '../config/load-config.js'
+import { createGitOps, type GitOps } from '../utils/git.js'
+import {
+  createNpmRunner,
+  defaultRegistryFetch,
+  defaultSpawn,
+  type NpmRegistryFetch,
+  type NpmRunner,
+  type SpawnFn,
+} from '../utils/npm.js'
+import { smokeTestTarball } from '../utils/smoke-test.js'
+
+export type { GitOps } from '../utils/git.js'
+export type { NpmRunner } from '../utils/npm.js'
+
+export type PublishOptions = {
+  skipTests?: boolean
+  cwd?: string
+  git?: GitOps
+  npm?: NpmRunner
+  registryFetch?: NpmRegistryFetch
+  spawn?: SpawnFn
+}
+
+const AUTHOR = '小橘 <xiaoju@shazhou.work>'
+
+async function readJson(path: string): Promise<Record<string, unknown>> {
+  const text = await readFile(path, 'utf8')
+  return JSON.parse(text) as Record<string, unknown>
+}
+
+function isRcVersion(version: string): boolean {
+  return /-rc\.\d+$/.test(version)
+}
+
+const ALREADY_PUBLISHED_RE =
+  /cannot publish over the previously published versions|you cannot publish over the previously published version/i
+
+function isAlreadyPublished(message: string): boolean {
+  return ALREADY_PUBLISHED_RE.test(message)
+}
+
+/**
+ * Publish all packages. Reads each package's version from its own package.json.
+ * build → test → check → smoke test tarball → publish → commit → tag → push
+ */
+export async function publish(opts: PublishOptions = {}): Promise<void> {
+  const { skipTests = false } = opts
+  const cwd = opts.cwd ?? process.cwd()
+  const git = opts.git ?? createGitOps(cwd)
+  const fetchVersions = opts.registryFetch ?? defaultRegistryFetch
+  const spawn = opts.spawn ?? defaultSpawn
+
+  const cfg = loadConfig(cwd)
+  const npm = opts.npm ?? createNpmRunner(cwd)
+
+  // Separate publishable (non-private) from private packages
+  type PkgJsonInfo = { version: string; private?: boolean }
+  const pkgJsonMap: Record<string, PkgJsonInfo> = {}
+  for (const pkg of cfg.packages) {
+    const pkgPath = resolve(cwd, pkg.path, 'package.json')
+    const json = await readJson(pkgPath)
+    const version = json.version as string
+    if (!version) throw new Error(`missing version in ${pkgPath}`)
+    pkgJsonMap[pkg.name] = { version, private: json.private === true }
+  }
+
+  const publishablePackages = cfg.packages.filter(
+    (pkg) => pkg.private !== true && pkgJsonMap[pkg.name]?.private !== true,
+  )
+
+  // Read each publishable package's version
+  const versions: Record<string, string> = {}
+  for (const pkg of publishablePackages) {
+    versions[pkg.name] = pkgJsonMap[pkg.name]?.version as string
+  }
+
+  // Build + test + check
+  await npm.install()
+  await npm.build()
+  console.log('✓ build')
+  if (!skipTests) {
+    await npm.test()
+    console.log('✓ test')
+  }
+  await npm.check()
+  console.log('✓ check')
+
+  // Log skipped private packages
+  for (const pkg of cfg.packages) {
+    if (pkg.private === true || pkgJsonMap[pkg.name]?.private === true) {
+      console.log(`⏭ skipped ${pkg.name} (private)`)
+    }
+  }
+
+  // Publish each publishable package
+  const access = cfg.release?.access
+  for (let i = 0; i < publishablePackages.length; i++) {
+    const entry = publishablePackages[i]
+    const version = versions[entry.name] as string
+    const isRc = isRcVersion(version)
+    const publishTag = isRc ? 'rc' : 'latest'
+    const pkgDir = resolve(cwd, entry.path)
+
+    // Pre-check: skip if already published on registry
+    const existingVersions = await fetchVersions(entry.name)
+    if (existingVersions.includes(version)) {
+      console.log(`⏭ skipped ${entry.name}@${version} (already published)`)
+      continue
+    }
+
+    // Smoke test: validate tarball before publishing
+    try {
+      await smokeTestTarball(pkgDir, spawn)
+    } catch (err) {
+      const message = (err as Error).message
+      const published = publishablePackages.slice(0, i).map((p) => p.name)
+      const remaining = publishablePackages.slice(i + 1).map((p) => p.name)
+      const msg =
+        `smoke test failed for ${entry.name}: ${message}\n` +
+        `  published: ${published.join(', ') || '(none)'}\n` +
+        `  unpublished: ${[entry.name, ...remaining].join(', ')}`
+      throw new Error(msg)
+    }
+
+    try {
+      await npm.publish(pkgDir, { tag: publishTag, ...(access ? { access } : {}) })
+      console.log(`✓ published ${entry.name}@${version}`)
+    } catch (err) {
+      const message = (err as Error).message
+      // Fallback: catch the error in case of race condition
+      if (isAlreadyPublished(message)) {
+        console.log(`⏭ skipped ${entry.name}@${version} (already published)`)
+        continue
+      }
+      const published = publishablePackages.slice(0, i).map((p) => p.name)
+      const remaining = publishablePackages.slice(i + 1).map((p) => p.name)
+      const msg =
+        `publish failed for ${entry.name}: ${message}\n` +
+        `  published: ${published.join(', ') || '(none)'}\n` +
+        `  unpublished: ${[entry.name, ...remaining].join(', ')}`
+      throw new Error(msg)
+    }
+  }
+
+  // Commit + tag + push all publishable packages
+  // Changelog generation and changeset cleanup are now bump's responsibility (issue #74)
+  await git.addAll()
+
+  const tagPrefix = cfg.release?.gitTagPrefix ?? 'v'
+  const bumpedVersions = Object.entries(versions)
+
+  const commitVersion = bumpedVersions[0]?.[1] ?? 'unknown'
+  await git.commit(`release: v${commitVersion}`, AUTHOR)
+
+  for (const [pkgName, version] of bumpedVersions) {
+    const tagName = `${pkgName}@${tagPrefix}${version}`
+    await git.tag(tagName, `Release ${pkgName}@${version}`)
+  }
+  await git.pushTags()
+  await git.push('main')
+  for (const [pkgName, version] of bumpedVersions) {
+    console.log(`✓ tagged ${pkgName}@${tagPrefix}${version}`)
+  }
+  console.log(`✓ pushed`)
+}

package/src/config/index.ts

@@ -0,0 +1,8 @@
+export { loadConfig } from './load-config.js'
+export type {
+  PackageEntry,
+  PackageType,
+  PromanConfig,
+  ReleaseConfig,
+} from './types.js'
+export { validateConfig } from './validate-config.js'

package/src/config/load-config.ts

@@ -0,0 +1,33 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { parse } from 'yaml'
+import type { PromanConfig, ReleaseConfig } from './types.js'
+import { validateConfig } from './validate-config.js'
+
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org'
+const DEFAULT_GIT_TAG_PREFIX = 'v'
+
+function applyDefaults(config: PromanConfig): PromanConfig {
+  const release: ReleaseConfig = {
+    registry: config.release?.registry ?? DEFAULT_REGISTRY,
+    gitTagPrefix: config.release?.gitTagPrefix ?? DEFAULT_GIT_TAG_PREFIX,
+  }
+  if (config.release?.access !== undefined) {
+    release.access = config.release.access
+  }
+  return { ...config, release }
+}
+
+/**
+ * Loads `proman.yaml` from the given cwd (or `process.cwd()`).
+ */
+export function loadConfig(cwd: string = process.cwd()): PromanConfig {
+  const absPath = resolve(cwd, 'proman.yaml')
+  if (!existsSync(absPath)) {
+    throw new Error(`proman.yaml not found at ${absPath}`)
+  }
+  const text = readFileSync(absPath, 'utf8')
+  const raw = parse(text)
+  const validated = validateConfig(raw)
+  return applyDefaults(validated)
+}