@shazhou/proman-core 0.9.0

package/src/utils/smoke-test.ts

@@ -0,0 +1,79 @@
+import { readFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { SpawnFn } from './npm.js'
+
+type PackageJson = {
+  name: string
+  version: string
+  bin?: string | Record<string, string>
+}
+
+/**
+ * Smoke test a package tarball by extracting it and running bin commands.
+ * Validates that the packaged artifact actually works before publishing.
+ */
+export async function smokeTestTarball(pkgDir: string, spawn: SpawnFn): Promise<void> {
+  // Read package.json to check for bin entries
+  const pkgJsonPath = join(pkgDir, 'package.json')
+  const pkgJsonText = await readFile(pkgJsonPath, 'utf8')
+  const pkgJson = JSON.parse(pkgJsonText) as PackageJson
+
+  // Skip if no bin entry
+  if (!pkgJson.bin) {
+    return
+  }
+
+  // Normalize bin to Record format
+  const binEntries: Record<string, string> =
+    typeof pkgJson.bin === 'string' ? { [pkgJson.name]: pkgJson.bin } : pkgJson.bin
+
+  // Skip if bin is empty
+  if (Object.keys(binEntries).length === 0) {
+    return
+  }
+
+  // Step 1: Create tarball with pnpm pack
+  const packResult = await spawn(['pnpm', 'pack'], pkgDir)
+  if (packResult.code !== 0) {
+    throw new Error(`pnpm pack failed: ${packResult.stderr || packResult.stdout}`)
+  }
+
+  const tarballName = packResult.stdout.trim()
+  if (!tarballName) {
+    throw new Error('pnpm pack did not return tarball filename')
+  }
+
+  // Step 2: Extract tarball to temp directory
+  const { mkdtemp } = await import('node:fs/promises')
+  const testDir = await mkdtemp(join(tmpdir(), 'proman-smoke-'))
+
+  try {
+    // Extract tarball
+    const tarballPath = join(pkgDir, tarballName)
+    const extractResult = await spawn(['tar', '-xzf', tarballPath, '-C', testDir], pkgDir)
+    if (extractResult.code !== 0) {
+      throw new Error(`tar extract failed: ${extractResult.stderr}`)
+    }
+
+    // pnpm pack creates a 'package/' directory inside the tarball
+    const extractedPkgDir = join(testDir, 'package')
+
+    // Step 3: Test each bin entry
+    for (const [binName, binPath] of Object.entries(binEntries)) {
+      const binFullPath = join(extractedPkgDir, binPath)
+      const binTestResult = await spawn(['node', binFullPath, '--version'], extractedPkgDir)
+
+      if (binTestResult.code !== 0) {
+        const errorMsg = binTestResult.stderr.trim() || binTestResult.stdout.trim()
+        throw new Error(
+          `smoke test failed for bin '${binName}': ${errorMsg || 'non-zero exit code'}`,
+        )
+      }
+    }
+  } finally {
+    // Step 4: Always clean up temp directory and tarball
+    await rm(testDir, { recursive: true, force: true })
+    await rm(join(pkgDir, tarballName), { force: true })
+  }
+}

package/src/utils/version.ts

@@ -0,0 +1,41 @@
+import type { Bump, Changeset } from './changeset.js'
+
+const VERSION_CORE_RE = /^(\d+)\.(\d+)\.(\d+)(?:-[\w.+-]+)?$/
+
+export function bumpVersion(current: string, bump: Bump): string {
+  const m = current.match(VERSION_CORE_RE)
+  if (!m) {
+    throw new Error(`invalid version: '${current}'`)
+  }
+  const major = Number(m[1])
+  const minor = Number(m[2])
+  const patch = Number(m[3])
+  if (bump === 'major') return `${major + 1}.0.0`
+  if (bump === 'minor') return `${major}.${minor + 1}.0`
+  return `${major}.${minor}.${patch + 1}`
+}
+
+const ORDER: Record<Bump, number> = { patch: 1, minor: 2, major: 3 }
+
+export function inferBump(changesets: Changeset[]): Record<string, Bump> {
+  const result: Record<string, Bump> = {}
+  for (const c of changesets) {
+    for (const [pkg, bump] of Object.entries(c.packages)) {
+      const current = result[pkg]
+      if (current === undefined || ORDER[bump] > ORDER[current]) {
+        result[pkg] = bump
+      }
+    }
+  }
+  return result
+}
+
+const TAG_RE = /^v?(\d+\.\d+\.\d+(?:-[\w.+-]+)?)$/
+
+export function parseTagVersion(tag: string): string {
+  const m = tag.match(TAG_RE)
+  if (!m) {
+    throw new Error(`invalid tag: '${tag}'`)
+  }
+  return m[1] as string
+}

package/src/utils/workspace.ts

@@ -0,0 +1,94 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+export type PkgManifest = {
+  name: string
+  version: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  [k: string]: unknown
+}
+
+type Unresolved = { pkg: string; dep: string }
+
+function rewriteDepsField(
+  pkgName: string,
+  field: Record<string, string> | undefined,
+  versions: Map<string, string>,
+  unresolved: Unresolved[],
+): Record<string, string> | undefined {
+  if (!field) return undefined
+  const out: Record<string, string> = {}
+  let changed = false
+  for (const [dep, val] of Object.entries(field)) {
+    if (val === 'workspace:*') {
+      const v = versions.get(dep)
+      if (v) {
+        out[dep] = v
+        changed = true
+      } else {
+        out[dep] = val
+        unresolved.push({ pkg: pkgName, dep })
+      }
+    } else {
+      out[dep] = val
+    }
+  }
+  // Mark via reference identity if changed; caller can compare to original
+  void changed
+  return out
+}
+
+export function rewriteWorkspaceDeps(manifests: PkgManifest[]): {
+  rewritten: PkgManifest[]
+  unresolved: Unresolved[]
+} {
+  const versions = new Map<string, string>()
+  for (const m of manifests) {
+    versions.set(m.name, m.version)
+  }
+  const unresolved: Unresolved[] = []
+  const rewritten = manifests.map((m) => {
+    const copy: PkgManifest = { ...m }
+    if (m.dependencies) {
+      copy.dependencies = rewriteDepsField(m.name, m.dependencies, versions, unresolved)
+    }
+    if (m.devDependencies) {
+      copy.devDependencies = rewriteDepsField(m.name, m.devDependencies, versions, unresolved)
+    }
+    return copy
+  })
+  return { rewritten, unresolved }
+}
+
+export async function applyWorkspaceRewrites(
+  rootDir: string,
+  packages: { name: string; path: string }[],
+): Promise<string[]> {
+  const paths = packages.map((p) => resolve(rootDir, p.path, 'package.json'))
+  const manifests: PkgManifest[] = []
+  for (let i = 0; i < paths.length; i++) {
+    const p = paths[i] as string
+    let text: string
+    try {
+      text = await readFile(p, 'utf8')
+    } catch (err) {
+      throw new Error(`package.json not found at ${p}: ${(err as Error).message}`)
+    }
+    manifests.push(JSON.parse(text) as PkgManifest)
+  }
+
+  const { rewritten } = rewriteWorkspaceDeps(manifests)
+  const changed: string[] = []
+  for (let i = 0; i < paths.length; i++) {
+    const before = JSON.stringify(manifests[i])
+    const after = JSON.stringify(rewritten[i])
+    if (before !== after) {
+      const p = paths[i] as string
+      const newText = `${JSON.stringify(rewritten[i], null, 2)}\n`
+      await writeFile(p, newText)
+      changed.push(p)
+    }
+  }
+  return changed
+}

package/tests/build-fingerprint-integration.test.ts

@@ -0,0 +1,403 @@
+/**
+ * Integration tests for build fingerprint caching (fixes #135).
+ *
+ * Verifies that build fingerprints stored inside `dist/` are correctly
+ * invalidated when the output directory is removed, and that incremental
+ * builds skip unchanged packages.
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import { build } from '../src/commands/dev.ts'
+
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = resolve(
+    tmpdir(),
+    `proman-build-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  mkdirSync(tmpDir, { recursive: true })
+})
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+function setupMonorepo(): void {
+  // Create proman.yaml config
+  writeFileSync(
+    join(tmpDir, 'proman.yaml'),
+    `
+packages:
+  - name: '@test/pkg'
+    path: packages/pkg
+    type: lib
+`,
+  )
+
+  // Create package
+  mkdirSync(join(tmpDir, 'packages/pkg/src'), { recursive: true })
+  writeFileSync(join(tmpDir, 'packages/pkg/src/index.ts'), 'export const x = 1')
+  writeFileSync(
+    join(tmpDir, 'packages/pkg/package.json'),
+    JSON.stringify({ name: '@test/pkg', version: '1.0.0' }),
+  )
+  writeFileSync(join(tmpDir, 'packages/pkg/tsconfig.json'), '{}')
+}
+
+function setupMultiPackageMonorepo(): void {
+  writeFileSync(
+    join(tmpDir, 'proman.yaml'),
+    `
+packages:
+  - name: '@test/core'
+    path: packages/core
+    type: lib
+  - name: '@test/fs'
+    path: packages/fs
+    type: lib
+  - name: '@test/cli'
+    path: packages/cli
+    type: cli
+`,
+  )
+
+  // core — no workspace deps
+  mkdirSync(join(tmpDir, 'packages/core/src'), { recursive: true })
+  writeFileSync(join(tmpDir, 'packages/core/src/index.ts'), 'export const x = 1')
+  writeFileSync(
+    join(tmpDir, 'packages/core/package.json'),
+    JSON.stringify({ name: '@test/core', version: '1.0.0' }),
+  )
+  writeFileSync(join(tmpDir, 'packages/core/tsconfig.json'), '{}')
+
+  // fs — depends on core
+  mkdirSync(join(tmpDir, 'packages/fs/src'), { recursive: true })
+  writeFileSync(join(tmpDir, 'packages/fs/src/index.ts'), 'export const y = 2')
+  writeFileSync(
+    join(tmpDir, 'packages/fs/package.json'),
+    JSON.stringify({
+      name: '@test/fs',
+      version: '1.0.0',
+      dependencies: { '@test/core': 'workspace:*' },
+    }),
+  )
+  writeFileSync(join(tmpDir, 'packages/fs/tsconfig.json'), '{}')
+
+  // cli — depends on fs
+  mkdirSync(join(tmpDir, 'packages/cli/src'), { recursive: true })
+  writeFileSync(join(tmpDir, 'packages/cli/src/index.ts'), 'export const z = 3')
+  writeFileSync(
+    join(tmpDir, 'packages/cli/package.json'),
+    JSON.stringify({
+      name: '@test/cli',
+      version: '1.0.0',
+      dependencies: { '@test/fs': 'workspace:*' },
+    }),
+  )
+  writeFileSync(join(tmpDir, 'packages/cli/tsconfig.json'), '{}')
+}
+
+// Mock spawn function that simulates successful tsc builds
+const mockSpawn = async (_argv: string[], cwd: string) => {
+  // Simulate tsc build by creating dist folder with output
+  const distDir = join(cwd, 'dist')
+  mkdirSync(distDir, { recursive: true })
+
+  // Create a simple index.js output
+  const srcIndexPath = join(cwd, 'src/index.ts')
+  if (existsSync(srcIndexPath)) {
+    const content = readFileSync(srcIndexPath, 'utf-8')
+    writeFileSync(join(distDir, 'index.js'), `// Compiled from TypeScript\n${content}`)
+  }
+
+  return { code: 0, stdout: 'Build succeeded', stderr: '' }
+}
+
+describe('Build Fingerprint Integration Tests (Issue #135)', () => {
+  test('T1: Fingerprint stored inside dist folder', async () => {
+    setupMonorepo()
+
+    await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+    // Verify fingerprint is inside dist folder
+    const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+    expect(existsSync(fpPath)).toBe(true)
+
+    // Verify old location is NOT used
+    const oldPath = join(tmpDir, '.proman/build/@test-pkg.fingerprint')
+    expect(existsSync(oldPath)).toBe(false)
+
+    // .proman directory should not be created
+    expect(existsSync(join(tmpDir, '.proman'))).toBe(false)
+  })
+
+  test('T2: Removing dist invalidates fingerprint and forces rebuild', async () => {
+    setupMonorepo()
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => {
+      logs.push(msg)
+      originalLog(msg)
+    }
+
+    try {
+      // First build
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+      expect(existsSync(fpPath)).toBe(true)
+
+      // Clear logs
+      logs.length = 0
+
+      // Second build without changes - should skip
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+      expect(logs.some((log) => log.includes('⏭ build: @test/pkg (unchanged)'))).toBe(true)
+
+      // Remove dist folder
+      rmSync(join(tmpDir, 'packages/pkg/dist'), { recursive: true })
+
+      // Clear logs
+      logs.length = 0
+
+      // Third build - should rebuild (dist is gone)
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      // Should NOT skip (no skip log)
+      expect(logs.some((log) => log.includes('⏭ build: @test/pkg (unchanged)'))).toBe(false)
+
+      // New fingerprint written
+      expect(existsSync(fpPath)).toBe(true)
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('T3: Unchanged source with intact dist skips build', async () => {
+    setupMonorepo()
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => {
+      logs.push(msg)
+      originalLog(msg)
+    }
+
+    try {
+      // First build
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+      const fpBefore = readFileSync(fpPath, 'utf-8')
+
+      // Clear logs
+      logs.length = 0
+
+      // Second build without changes - should skip
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+      expect(logs.some((log) => log.includes('⏭ build: @test/pkg (unchanged)'))).toBe(true)
+
+      // Fingerprint unchanged
+      const fpAfter = readFileSync(fpPath, 'utf-8')
+      expect(fpAfter).toBe(fpBefore)
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('T4: Changed source invalidates fingerprint even with intact dist', async () => {
+    setupMonorepo()
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => {
+      logs.push(msg)
+      originalLog(msg)
+    }
+
+    try {
+      // First build
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+      const fpBefore = readFileSync(fpPath, 'utf-8')
+
+      // Modify source
+      writeFileSync(join(tmpDir, 'packages/pkg/src/index.ts'), 'export const x = 999')
+
+      // Clear logs
+      logs.length = 0
+
+      // Second build with changed source - should rebuild
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      // Should NOT skip
+      expect(logs.some((log) => log.includes('⏭ build: @test/pkg (unchanged)'))).toBe(false)
+
+      // New fingerprint written
+      const fpAfter = readFileSync(fpPath, 'utf-8')
+      expect(fpAfter).not.toBe(fpBefore)
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('T5: Multiple packages each have fingerprints in their own dist', async () => {
+    setupMultiPackageMonorepo()
+
+    await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+    // Each package has fingerprint in its own dist
+    expect(existsSync(join(tmpDir, 'packages/core/dist/.build-fingerprint'))).toBe(true)
+    expect(existsSync(join(tmpDir, 'packages/fs/dist/.build-fingerprint'))).toBe(true)
+    expect(existsSync(join(tmpDir, 'packages/cli/dist/.build-fingerprint'))).toBe(true)
+
+    // No fingerprints in .proman/build directory
+    expect(existsSync(join(tmpDir, '.proman/build'))).toBe(false)
+  })
+
+  test('T6: Dependency propagation still works with new location', async () => {
+    setupMultiPackageMonorepo()
+
+    // First build
+    await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+    const coreFpBefore = readFileSync(
+      join(tmpDir, 'packages/core/dist/.build-fingerprint'),
+      'utf-8',
+    )
+    const fsFpBefore = readFileSync(join(tmpDir, 'packages/fs/dist/.build-fingerprint'), 'utf-8')
+    const cliFpBefore = readFileSync(join(tmpDir, 'packages/cli/dist/.build-fingerprint'), 'utf-8')
+
+    // Modify core's source
+    writeFileSync(join(tmpDir, 'packages/core/src/index.ts'), 'export const x = 999')
+
+    // Second build
+    await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+    // All packages should have new fingerprints (dependency propagation)
+    const coreFpAfter = readFileSync(join(tmpDir, 'packages/core/dist/.build-fingerprint'), 'utf-8')
+    const fsFpAfter = readFileSync(join(tmpDir, 'packages/fs/dist/.build-fingerprint'), 'utf-8')
+    const cliFpAfter = readFileSync(join(tmpDir, 'packages/cli/dist/.build-fingerprint'), 'utf-8')
+
+    expect(coreFpAfter).not.toBe(coreFpBefore)
+    expect(fsFpAfter).not.toBe(fsFpBefore)
+    expect(cliFpAfter).not.toBe(cliFpBefore)
+  })
+
+  test('T7: Force flag bypasses cache regardless of fingerprint location', async () => {
+    setupMonorepo()
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => {
+      logs.push(msg)
+      originalLog(msg)
+    }
+
+    try {
+      // First build
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+      const _fpBefore = readFileSync(fpPath, 'utf-8')
+
+      // Clear logs
+      logs.length = 0
+
+      // Second build with force - should rebuild
+      await build({ cwd: tmpDir, force: true, spawn: mockSpawn })
+
+      // Should NOT skip
+      expect(logs.some((log) => log.includes('⏭ build: @test/pkg (unchanged)'))).toBe(false)
+
+      // Fingerprint is rewritten (even if content is the same)
+      expect(existsSync(fpPath)).toBe(true)
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('T8: CI mode always rebuilds and writes fingerprints', async () => {
+    setupMonorepo()
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => {
+      logs.push(msg)
+      originalLog(msg)
+    }
+
+    try {
+      // First build with force=false (enable fingerprints)
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+      expect(existsSync(fpPath)).toBe(true)
+
+      // Clear logs
+      logs.length = 0
+
+      // Second build with force=true (simulates CI mode) - should rebuild
+      await build({ cwd: tmpDir, force: true, spawn: mockSpawn })
+
+      // Should NOT skip (CI always rebuilds)
+      expect(logs.some((log) => log.includes('⏭ build: @test/pkg (unchanged)'))).toBe(false)
+
+      // Fingerprint is still written (even in force mode)
+      expect(existsSync(fpPath)).toBe(true)
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('T9: Build failure does not write fingerprint', async () => {
+    setupMonorepo()
+
+    // Mock spawn that fails
+    const failingSpawn = async () => {
+      return { code: 1, stdout: '', stderr: 'Build failed' }
+    }
+
+    // Build should throw
+    await expect(build({ cwd: tmpDir, force: false, spawn: failingSpawn })).rejects.toThrow()
+
+    // No fingerprint written
+    const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+    expect(existsSync(fpPath)).toBe(false)
+  })
+
+  test('T10: Partial dist deletion (missing fingerprint) forces rebuild', async () => {
+    setupMonorepo()
+    const logs: string[] = []
+    const originalLog = console.log
+    console.log = (msg: string) => {
+      logs.push(msg)
+      originalLog(msg)
+    }
+
+    try {
+      // First build
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      const fpPath = join(tmpDir, 'packages/pkg/dist/.build-fingerprint')
+      expect(existsSync(fpPath)).toBe(true)
+
+      // Delete only fingerprint (keep dist folder)
+      rmSync(fpPath)
+
+      // Clear logs
+      logs.length = 0
+
+      // Second build - should rebuild (missing fingerprint)
+      await build({ cwd: tmpDir, force: false, spawn: mockSpawn })
+
+      // Should NOT skip (no skip log)
+      expect(logs.some((log) => log.includes('⏭ build: @test/pkg (unchanged)'))).toBe(false)
+
+      // New fingerprint written
+      expect(existsSync(fpPath)).toBe(true)
+    } finally {
+      console.log = originalLog
+    }
+  })
+})