@shazhou/proman-core 0.9.0

package/src/commands/dev.ts

@@ -0,0 +1,214 @@
+import { chmodSync, existsSync, readdirSync, readFileSync, rmSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { loadConfig } from '../config/index.js'
+import {
+  computeBuildFingerprints,
+  computeRootFingerprint,
+  fingerprintPath,
+  readFingerprint,
+  writeFingerprint,
+} from '../utils/fingerprint.js'
+import { defaultSpawn, runOrThrow, type SpawnFn } from '../utils/npm.js'
+
+export type DevCommandOptions = {
+  cwd: string
+  spawn?: SpawnFn
+  /** When provided, enables fingerprint caching.
+   *  - false: check fingerprint, skip if match
+   *  - true: always run (--force / CI)
+   *  - undefined: legacy behavior — always run, no fingerprint logic */
+  force?: boolean
+}
+
+function pnpmExec(bin: string, ...args: string[]): string[] {
+  return ['pnpm', 'exec', bin, ...args]
+}
+
+export async function build(opts: DevCommandOptions): Promise<void> {
+  const spawn = opts.spawn ?? defaultSpawn
+  const cwd = resolve(opts.cwd)
+  const cfg = loadConfig(cwd)
+  const useFingerprint = opts.force !== undefined
+  const force = opts.force ?? false
+
+  // Compute fingerprints only when fingerprint caching is enabled
+  const fingerprints = useFingerprint ? computeBuildFingerprints(cwd, cfg.packages) : null
+
+  // Determine which packages to build
+  const toRun: { idx: number; pkgDir: string; fpPath: string; fpValue: string }[] = []
+
+  for (let i = 0; i < cfg.packages.length; i++) {
+    const pkg = cfg.packages[i] as (typeof cfg.packages)[number]
+    const pkgDir = resolve(cwd, pkg.path)
+
+    const fpPath = fingerprintPath(pkgDir, 'build', pkg.name)
+    const fpValue = fingerprints?.get(pkg.name) ?? ''
+
+    if (useFingerprint && !force) {
+      const stored = readFingerprint(fpPath)
+      if (stored === fpValue) {
+        console.log(`⏭ build: ${pkg.name} (unchanged)`)
+        continue // skip — fingerprint matches
+      }
+    }
+
+    toRun.push({ idx: i, pkgDir, fpPath, fpValue })
+  }
+
+  // Execute builds
+  for (const { idx, pkgDir } of toRun) {
+    const pkg = cfg.packages[idx] as (typeof cfg.packages)[number]
+    // Clean output dir + tsbuildinfo before build to prevent stale artifacts.
+    // Note: since build fingerprints live inside dist/ (see fingerprintPath()),
+    // removing dist/ intentionally invalidates the build cache for this package.
+    const outDir = join(pkgDir, 'dist')
+    if (existsSync(outDir)) {
+      rmSync(outDir, { recursive: true })
+    }
+    const buildInfo = join(pkgDir, 'tsconfig.tsbuildinfo')
+    if (existsSync(buildInfo)) {
+      rmSync(buildInfo)
+    }
+    let argv: string[]
+    switch (pkg.type) {
+      case 'webui':
+        argv = pnpmExec('vite', 'build')
+        break
+      case 'cli':
+        // cli → use package's own build script (may be esbuild, tsc, etc.)
+        argv = ['pnpm', 'run', 'build']
+        break
+      default:
+        // lib | api → tsc --build
+        argv = pnpmExec('tsc', '--build')
+        break
+    }
+    await runOrThrow(spawn, argv, pkgDir)
+
+    // chmod +x bin entries so linked CLIs survive tsc rebuild
+    chmodBinEntries(pkgDir)
+  }
+
+  // Write fingerprints only after ALL builds succeed (and only when enabled)
+  if (useFingerprint) {
+    for (const { fpPath, fpValue } of toRun) {
+      writeFingerprint(fpPath, fpValue)
+    }
+  }
+}
+
+function chmodBinEntries(pkgDir: string): void {
+  const pkgJsonPath = join(pkgDir, 'package.json')
+  if (!existsSync(pkgJsonPath)) return
+  const json = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'))
+  const bin: unknown = json.bin
+  if (bin == null) return
+  const paths =
+    typeof bin === 'string'
+      ? [bin]
+      : typeof bin === 'object'
+        ? Object.values(bin as Record<string, string>)
+        : []
+  for (const rel of paths) {
+    const abs = resolve(pkgDir, rel)
+    if (existsSync(abs)) {
+      chmodSync(abs, 0o755)
+    }
+  }
+}
+
+export async function runTests(opts: DevCommandOptions): Promise<void> {
+  const spawn = opts.spawn ?? defaultSpawn
+  const cwd = resolve(opts.cwd)
+  const useFingerprint = opts.force !== undefined
+  const force = opts.force ?? false
+
+  if (useFingerprint) {
+    const fpPath = fingerprintPath(cwd, 'test')
+    const fpValue = computeRootFingerprint(cwd, 'test')
+
+    if (!force) {
+      const stored = readFingerprint(fpPath)
+      if (stored === fpValue) {
+        console.log('⏭ test (unchanged)')
+        return // skip
+      }
+    }
+
+    await runOrThrow(spawn, pnpmExec('vitest', 'run'), cwd)
+    writeFingerprint(fpPath, fpValue)
+  } else {
+    await runOrThrow(spawn, pnpmExec('vitest', 'run'), cwd)
+  }
+}
+
+export async function check(opts: DevCommandOptions): Promise<void> {
+  const spawn = opts.spawn ?? defaultSpawn
+  const cwd = resolve(opts.cwd)
+  const useFingerprint = opts.force !== undefined
+  const force = opts.force ?? false
+
+  if (useFingerprint) {
+    const fpPath = fingerprintPath(cwd, 'check')
+    const fpValue = computeRootFingerprint(cwd, 'check')
+
+    if (!force) {
+      const stored = readFingerprint(fpPath)
+      if (stored === fpValue) {
+        console.log('⏭ check (unchanged)')
+        return // skip
+      }
+    }
+
+    await runOrThrow(spawn, pnpmExec('biome', 'check', '.'), cwd)
+    await validateWorkflows(spawn, cwd)
+    writeFingerprint(fpPath, fpValue)
+  } else {
+    await runOrThrow(spawn, pnpmExec('biome', 'check', '.'), cwd)
+    await validateWorkflows(spawn, cwd)
+  }
+}
+
+export async function format(opts: DevCommandOptions): Promise<void> {
+  const spawn = opts.spawn ?? defaultSpawn
+  const cwd = resolve(opts.cwd)
+  await runOrThrow(spawn, pnpmExec('biome', 'format', '--write', '.'), cwd)
+}
+
+/** Discover .workflows/*.yaml and validate each with `uwf workflow validate`. Skips if uwf is not installed. */
+async function validateWorkflows(spawn: SpawnFn, cwd: string): Promise<void> {
+  const dirs = [join(cwd, '.workflows'), join(cwd, '.workflow')]
+  const files: string[] = []
+
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue
+    for (const entry of readdirSync(dir)) {
+      if (entry.endsWith('.yaml') || entry.endsWith('.yml')) {
+        files.push(join(dir, entry))
+      }
+    }
+  }
+
+  if (files.length === 0) return
+
+  // Check if uwf is available
+  const { code: uwfCheck } = await spawn(['which', 'uwf'], cwd)
+  if (uwfCheck !== 0) {
+    console.log('⚠ uwf not installed, skipping workflow validation')
+    return
+  }
+
+  const errors: string[] = []
+  for (const file of files) {
+    const { code, stderr } = await spawn(['uwf', 'workflow', 'validate', file], cwd)
+    if (code !== 0) {
+      errors.push(`${file}: ${stderr.trim() || 'validation failed'}`)
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Workflow validation failed:\n${errors.join('\n')}`)
+  }
+
+  console.log(`✓ ${files.length} workflow(s) validated`)
+}

package/src/commands/index.ts

@@ -0,0 +1,7 @@
+// Export all command functions
+export { type BumpOptions, bump } from './bump.js'
+export { type DeployCommandOptions, deploy } from './deploy.js'
+export { build, check, type DevCommandOptions, format, runTests } from './dev.js'
+export { type InitOptions, init } from './init.js'
+export { type LinkCommandOptions, link, linkStatus, unlink } from './link.js'
+export { type PublishOptions, publish } from './publish.js'

package/src/commands/init.integration.test.ts

@@ -0,0 +1,59 @@
+import { execSync } from 'node:child_process'
+import { existsSync, mkdirSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, beforeAll, describe, expect, test } from 'vitest'
+
+// Skip: beforeAll pnpm install times out on CI (cold cache, 60s limit)
+// Unit tests in init.test.ts cover structure; this only adds smoke-test of generated project
+// See: https://git.shazhou.work/shazhou/proman/issues/171
+describe.skip('proman init integration', () => {
+  let testDir: string
+  let projectDir: string
+
+  beforeAll(() => {
+    // Create a unique temp directory for integration test
+    testDir = join(
+      tmpdir(),
+      `proman-init-integration-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    )
+    mkdirSync(testDir, { recursive: true })
+    projectDir = join(testDir, 'test-project')
+
+    // Get the path to the proman CLI (used only for init — the generated project uses its own)
+    const promanBin = join(process.cwd(), 'dist', 'cli.js')
+
+    // Run proman init
+    execSync(`node ${promanBin} init test-project`, { cwd: testDir })
+
+    // Install dependencies — this installs @shazhou/proman as a devDep inside the generated project.
+    // 60s timeout: pnpm install can be slow on first run (cold cache, registry fetch).
+    execSync('pnpm install', { cwd: projectDir, stdio: 'inherit' })
+  }, 60_000)
+
+  afterAll(() => {
+    // Clean up the test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+  })
+
+  test('proman build succeeds', () => {
+    // Use the generated project's own proman (installed as devDep), not the parent's
+    expect(() => {
+      execSync('pnpm exec proman build', { cwd: projectDir, stdio: 'inherit' })
+    }).not.toThrow()
+  })
+
+  test('proman test succeeds', () => {
+    expect(() => {
+      execSync('pnpm exec proman test', { cwd: projectDir, stdio: 'inherit' })
+    }).not.toThrow()
+  })
+
+  test('proman check succeeds', () => {
+    expect(() => {
+      execSync('pnpm exec proman check', { cwd: projectDir, stdio: 'inherit' })
+    }).not.toThrow()
+  })
+})

package/src/commands/init.test.ts

@@ -0,0 +1,179 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import { init } from './init.js'
+
+describe('proman init', () => {
+  let testDir: string
+
+  beforeEach(() => {
+    // Create a unique temp directory for each test
+    testDir = join(
+      tmpdir(),
+      `proman-init-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    )
+    mkdirSync(testDir, { recursive: true })
+  })
+
+  afterEach(() => {
+    // Clean up the test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+  })
+
+  test('creates full monorepo structure with target directory', async () => {
+    const projectDir = join(testDir, 'my-project')
+
+    await init({ targetDir: projectDir })
+
+    // Verify root directory exists
+    expect(existsSync(projectDir)).toBe(true)
+
+    // Verify root files
+    const rootPackageJson = JSON.parse(readFileSync(join(projectDir, 'package.json'), 'utf-8'))
+    expect(rootPackageJson.private).toBe(true)
+    expect(rootPackageJson.scripts).toBeDefined()
+    expect(rootPackageJson.scripts.build).toBe('proman build')
+    expect(rootPackageJson.scripts.test).toBe('proman test')
+    expect(rootPackageJson.scripts.check).toBe('proman check')
+    expect(rootPackageJson.scripts.format).toBe('proman format')
+    expect(rootPackageJson.devDependencies['@shazhou/proman']).toBeDefined()
+
+    expect(existsSync(join(projectDir, 'proman.yaml'))).toBe(true)
+    expect(existsSync(join(projectDir, 'pnpm-workspace.yaml'))).toBe(true)
+    expect(existsSync(join(projectDir, 'biome.json'))).toBe(true)
+    expect(existsSync(join(projectDir, 'tsconfig.json'))).toBe(true)
+    expect(existsSync(join(projectDir, '.gitignore'))).toBe(true)
+
+    // Verify gitignore content
+    const gitignore = readFileSync(join(projectDir, '.gitignore'), 'utf-8')
+    expect(gitignore).toContain('node_modules')
+    expect(gitignore).toContain('dist')
+    expect(gitignore).toContain('.proman')
+    expect(gitignore).toContain('*.tsbuildinfo')
+
+    // Verify pnpm-workspace.yaml
+    const workspace = readFileSync(join(projectDir, 'pnpm-workspace.yaml'), 'utf-8')
+    expect(workspace).toContain('packages/*')
+
+    // Verify core package
+    const corePackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/core/package.json'), 'utf-8'),
+    )
+    expect(corePackageJson.name).toBe('@my-project/core')
+    expect(corePackageJson.type).toBe('module')
+    expect(corePackageJson.exports).toBeDefined()
+
+    expect(existsSync(join(projectDir, 'packages/core/tsconfig.json'))).toBe(true)
+    expect(existsSync(join(projectDir, 'packages/core/src/index.ts'))).toBe(true)
+    expect(existsSync(join(projectDir, 'packages/core/src/index.test.ts'))).toBe(true)
+
+    const coreIndex = readFileSync(join(projectDir, 'packages/core/src/index.ts'), 'utf-8')
+    expect(coreIndex).toContain('export function hello()')
+
+    const coreTest = readFileSync(join(projectDir, 'packages/core/src/index.test.ts'), 'utf-8')
+    expect(coreTest).toContain('import')
+    expect(coreTest).toContain('hello')
+
+    // Verify CLI package
+    const cliPackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/cli/package.json'), 'utf-8'),
+    )
+    expect(cliPackageJson.name).toBe('@my-project/cli')
+    expect(cliPackageJson.bin).toEqual({ 'my-project': 'dist/cli.js' })
+    expect(cliPackageJson.dependencies).toEqual({ '@my-project/core': 'workspace:*' })
+
+    expect(existsSync(join(projectDir, 'packages/cli/tsconfig.json'))).toBe(true)
+    expect(existsSync(join(projectDir, 'packages/cli/src/cli.ts'))).toBe(true)
+    expect(existsSync(join(projectDir, 'packages/cli/src/cli.test.ts'))).toBe(true)
+
+    const cliSrc = readFileSync(join(projectDir, 'packages/cli/src/cli.ts'), 'utf-8')
+    expect(cliSrc).toContain('#!/usr/bin/env node')
+    expect(cliSrc).toContain('@my-project/core')
+
+    const cliTest = readFileSync(join(projectDir, 'packages/cli/src/cli.test.ts'), 'utf-8')
+    expect(cliTest).toContain('test')
+  })
+
+  test('init in current directory when no arg provided', async () => {
+    const projectDir = join(testDir, 'test-repo')
+    mkdirSync(projectDir)
+
+    await init({ targetDir: projectDir })
+
+    // Verify packages use directory name
+    const corePackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/core/package.json'), 'utf-8'),
+    )
+    expect(corePackageJson.name).toBe('@test-repo/core')
+
+    const cliPackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/cli/package.json'), 'utf-8'),
+    )
+    expect(cliPackageJson.name).toBe('@test-repo/cli')
+    expect(cliPackageJson.bin).toEqual({ 'test-repo': 'dist/cli.js' })
+  })
+
+  test('fails when target directory is not empty', async () => {
+    const projectDir = join(testDir, 'existing-project')
+    mkdirSync(projectDir, { recursive: true })
+    writeFileSync(join(projectDir, 'README.md'), '# existing')
+
+    await expect(init({ targetDir: projectDir })).rejects.toThrow(
+      /Directory is not empty.*existing-project/,
+    )
+  })
+
+  test('fails when target directory exists with content', async () => {
+    const projectDir = join(testDir, 'my-project')
+    mkdirSync(projectDir, { recursive: true })
+    writeFileSync(join(projectDir, 'package.json'), '{}')
+
+    await expect(init({ targetDir: projectDir })).rejects.toThrow(/not empty/)
+  })
+
+  test('sanitizes directory name with uppercase and special chars', async () => {
+    const projectDir = join(testDir, 'My-Project_v2!')
+    await init({ targetDir: projectDir })
+
+    const corePackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/core/package.json'), 'utf-8'),
+    )
+    expect(corePackageJson.name).toBe('@my-project_v2-/core')
+  })
+
+  test('sanitizes directory name starting with dot', async () => {
+    const projectDir = join(testDir, '.hidden-project')
+    await init({ targetDir: projectDir })
+
+    const corePackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/core/package.json'), 'utf-8'),
+    )
+    expect(corePackageJson.name).toBe('@hidden-project/core')
+  })
+
+  test('strips tilde from directory name', async () => {
+    const projectDir = join(testDir, 'my~project')
+    await init({ targetDir: projectDir })
+
+    const corePackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/core/package.json'), 'utf-8'),
+    )
+    expect(corePackageJson.name).toBe('@my-project/core')
+  })
+
+  test('truncates package name at 214 characters', async () => {
+    const longName = 'a'.repeat(250)
+    const projectDir = join(testDir, longName)
+    await init({ targetDir: projectDir })
+
+    const corePackageJson = JSON.parse(
+      readFileSync(join(projectDir, 'packages/core/package.json'), 'utf-8'),
+    )
+    // scope '@' + name + '/core' — the name segment itself is capped at 214
+    const nameSegment = corePackageJson.name.replace(/^@/, '').replace(/\/core$/, '')
+    expect(nameSegment.length).toBeLessThanOrEqual(214)
+  })
+})