@shazhou/proman-core 0.9.0

package/tests/smoke-test.test.ts

@@ -0,0 +1,211 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import type { SpawnFn } from '../src/utils/npm.ts'
+import { smokeTestTarball } from '../src/utils/smoke-test.ts'
+
+let tmp: string
+
+beforeEach(async () => {
+  const { mkdtemp } = await import('node:fs/promises')
+  const { tmpdir } = await import('node:os')
+  tmp = await mkdtemp(join(tmpdir(), 'proman-smoke-'))
+})
+
+afterEach(async () => {
+  const { rm } = await import('node:fs/promises')
+  await rm(tmp, { recursive: true })
+})
+
+// ── Core smoke test: package with bin entry ──
+
+describe('smoke test with bin entry', () => {
+  test('extracts tarball and runs bin --version successfully', async () => {
+    // Setup: create a minimal package structure with bin entry
+    const pkgDir = join(tmp, 'test-pkg')
+    await mkdir(pkgDir, { recursive: true })
+
+    const pkgJson = {
+      name: '@test/cli',
+      version: '1.0.0',
+      bin: { testcli: './cli.js' },
+    }
+    await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson, null, 2))
+
+    // Create a minimal working CLI
+    const cliScript = `#!/usr/bin/env node
+if (process.argv.includes('--version')) {
+  console.log('1.0.0');
+  process.exit(0);
+}
+`
+    await writeFile(join(pkgDir, 'cli.js'), cliScript)
+
+    // Mock spawn that simulates npm pack + successful bin execution
+    const spawnCalls: string[] = []
+    const mockSpawn: SpawnFn = async (argv, _cwd) => {
+      const cmd = argv.join(' ')
+      spawnCalls.push(cmd)
+
+      if (cmd.startsWith('pnpm pack')) {
+        // Return tarball filename
+        return { code: 0, stdout: 'test-cli-1.0.0.tgz\n', stderr: '' }
+      }
+
+      if (cmd.includes('--version')) {
+        // Simulate successful bin execution
+        return { code: 0, stdout: '1.0.0\n', stderr: '' }
+      }
+
+      return { code: 0, stdout: '', stderr: '' }
+    }
+
+    // When: smoke test runs
+    await smokeTestTarball(pkgDir, mockSpawn)
+
+    // Then: npm pack was called, bin --version was executed
+    expect(spawnCalls.some((c) => c.includes('pnpm pack'))).toBe(true)
+    expect(spawnCalls.some((c) => c.includes('--version'))).toBe(true)
+  })
+
+  test('tests all bin entries when multiple exist', async () => {
+    const pkgDir = join(tmp, 'multi-bin')
+    await mkdir(pkgDir, { recursive: true })
+
+    const pkgJson = {
+      name: '@test/tools',
+      version: '1.0.0',
+      bin: {
+        'tool-a': './bin-a.js',
+        'tool-b': './bin-b.js',
+      },
+    }
+    await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson, null, 2))
+
+    const spawnCalls: string[] = []
+    const mockSpawn: SpawnFn = async (argv) => {
+      spawnCalls.push(argv.join(' '))
+      if (argv.includes('pack')) {
+        return { code: 0, stdout: 'test-tools-1.0.0.tgz\n', stderr: '' }
+      }
+      return { code: 0, stdout: '1.0.0\n', stderr: '' }
+    }
+
+    await smokeTestTarball(pkgDir, mockSpawn)
+
+    // Should test both binaries
+    expect(spawnCalls.some((c) => c.includes('bin-a.js'))).toBe(true)
+    expect(spawnCalls.some((c) => c.includes('bin-b.js'))).toBe(true)
+  })
+})
+
+// ── Error handling: abort on failure ──
+
+describe('abort on smoke test failure', () => {
+  test('throws error when bin command fails', async () => {
+    const pkgDir = join(tmp, 'broken-pkg')
+    await mkdir(pkgDir, { recursive: true })
+
+    const pkgJson = {
+      name: '@test/broken',
+      version: '1.0.0',
+      bin: { broken: './cli.js' },
+    }
+    await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson, null, 2))
+
+    const mockSpawn: SpawnFn = async (argv) => {
+      if (argv.includes('pack')) {
+        return { code: 0, stdout: 'broken-1.0.0.tgz\n', stderr: '' }
+      }
+      // Simulate bin failure (e.g., missing file, broken import)
+      if (argv.includes('--version')) {
+        return {
+          code: 1,
+          stdout: '',
+          stderr: "Error: Cannot find module './missing-dep.js'",
+        }
+      }
+      return { code: 0, stdout: '', stderr: '' }
+    }
+
+    // Should throw with clear error message
+    await expect(smokeTestTarball(pkgDir, mockSpawn)).rejects.toThrow('smoke test failed')
+  })
+
+  test('includes error output in thrown error', async () => {
+    const pkgDir = join(tmp, 'error-pkg')
+    await mkdir(pkgDir, { recursive: true })
+
+    const pkgJson = {
+      name: '@test/error',
+      version: '1.0.0',
+      bin: { errcli: './cli.js' },
+    }
+    await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson, null, 2))
+
+    const mockSpawn: SpawnFn = async (argv) => {
+      if (argv.includes('pack')) {
+        return { code: 0, stdout: 'error-1.0.0.tgz\n', stderr: '' }
+      }
+      if (argv.includes('--version')) {
+        return {
+          code: 1,
+          stdout: '',
+          stderr: 'ENOENT: no such file or directory',
+        }
+      }
+      return { code: 0, stdout: '', stderr: '' }
+    }
+
+    await expect(smokeTestTarball(pkgDir, mockSpawn)).rejects.toThrow('ENOENT')
+  })
+})
+
+// ── Edge case: no bin entry ──
+
+describe('skip smoke test for packages without bin', () => {
+  test('skips smoke test when no bin entry exists', async () => {
+    const pkgDir = join(tmp, 'lib-pkg')
+    await mkdir(pkgDir, { recursive: true })
+
+    const pkgJson = {
+      name: '@test/lib',
+      version: '1.0.0',
+      // No bin entry
+    }
+    await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson, null, 2))
+
+    const spawnCalls: string[] = []
+    const mockSpawn: SpawnFn = async (argv) => {
+      spawnCalls.push(argv.join(' '))
+      return { code: 0, stdout: '', stderr: '' }
+    }
+
+    // Should complete without error and without calling npm pack
+    await smokeTestTarball(pkgDir, mockSpawn)
+
+    expect(spawnCalls.length).toBe(0)
+  })
+
+  test('skips when bin is empty object', async () => {
+    const pkgDir = join(tmp, 'empty-bin')
+    await mkdir(pkgDir, { recursive: true })
+
+    const pkgJson = {
+      name: '@test/empty',
+      version: '1.0.0',
+      bin: {},
+    }
+    await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson, null, 2))
+
+    const spawnCalls: string[] = []
+    const mockSpawn: SpawnFn = async (argv) => {
+      spawnCalls.push(argv.join(' '))
+      return { code: 0, stdout: '', stderr: '' }
+    }
+
+    await smokeTestTarball(pkgDir, mockSpawn)
+
+    expect(spawnCalls.length).toBe(0)
+  })
+})

package/tests/validate-config.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from 'vitest'
+import { validateConfig } from '../src/config/index.ts'
+
+const minimal = {
+  packages: [{ name: '@x/a', path: 'packages/a' }],
+}
+
+describe('validateConfig', () => {
+  test('accepts minimal valid config', () => {
+    const r = validateConfig(minimal)
+    expect(r.packages).toHaveLength(1)
+  })
+
+  test('rejects non-object input', () => {
+    expect(() => validateConfig(null)).toThrow(/object/i)
+    expect(() => validateConfig(undefined)).toThrow(/object/i)
+    expect(() => validateConfig(42)).toThrow(/object/i)
+  })
+
+  test('ignores unknown changeset field (backward compat)', () => {
+    // Old configs with changeset.fixed should not throw
+    const r = validateConfig({ ...minimal, changeset: { fixed: true } })
+    expect(r.packages).toHaveLength(1)
+  })
+
+  test('rejects invalid release.access', () => {
+    expect(() =>
+      validateConfig({
+        ...minimal,
+        release: { access: 'private' as unknown as 'public' },
+      }),
+    ).toThrow(/release\.access/)
+  })
+
+  test('T1: accepts each package type', () => {
+    for (const t of ['lib', 'cli', 'webui', 'api'] as const) {
+      const r = validateConfig({
+        ...minimal,
+        packages: [{ name: '@x/a', path: 'packages/a', type: t }],
+      })
+      expect(r.packages[0]?.type).toBe(t)
+    }
+  })
+
+  test('T2: defaults type to lib when omitted', () => {
+    const r = validateConfig(minimal)
+    expect(r.packages[0]?.type).toBe('lib')
+  })
+
+  test('T3: rejects unknown type string', () => {
+    expect(() =>
+      validateConfig({
+        ...minimal,
+        packages: [{ name: '@x/a', path: 'packages/a', type: 'frontend' }],
+      }),
+    ).toThrow(/packages\[0\]\.type/)
+  })
+
+  test('T4: rejects non-string type', () => {
+    expect(() =>
+      validateConfig({
+        ...minimal,
+        packages: [{ name: '@x/a', path: 'packages/a', type: 1 as unknown as string }],
+      }),
+    ).toThrow(/packages\[0\]\.type/)
+  })
+})

package/tests/version.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from 'vitest'
+import type { Changeset } from '../src/utils/changeset.ts'
+import { bumpVersion, inferBump, parseTagVersion } from '../src/utils/version.ts'
+
+describe('bumpVersion', () => {
+  test('patch/minor/major from 0.2.0', () => {
+    expect(bumpVersion('0.2.0', 'patch')).toBe('0.2.1')
+    expect(bumpVersion('0.2.0', 'minor')).toBe('0.3.0')
+    expect(bumpVersion('0.2.0', 'major')).toBe('1.0.0')
+  })
+
+  test('patch/minor/major from 1.4.7', () => {
+    expect(bumpVersion('1.4.7', 'patch')).toBe('1.4.8')
+    expect(bumpVersion('1.4.7', 'minor')).toBe('1.5.0')
+    expect(bumpVersion('1.4.7', 'major')).toBe('2.0.0')
+  })
+
+  test('strips pre-release suffix', () => {
+    expect(bumpVersion('0.2.0-rc.1', 'patch')).toBe('0.2.1')
+  })
+
+  test('throws on invalid input', () => {
+    expect(() => bumpVersion('abc', 'patch')).toThrow(/invalid version/i)
+    expect(() => bumpVersion('', 'patch')).toThrow(/invalid version/i)
+    expect(() => bumpVersion('1.2', 'patch')).toThrow(/invalid version/i)
+    expect(() => bumpVersion('1.2.3.4', 'patch')).toThrow(/invalid version/i)
+  })
+})
+
+function cs(packages: Record<string, 'major' | 'minor' | 'patch'>, file = 'foo.md'): Changeset {
+  return { file, packages, body: '' }
+}
+
+describe('inferBump', () => {
+  test('empty list → empty map', () => {
+    expect(inferBump([])).toEqual({})
+  })
+
+  test('all-empty package records → empty map', () => {
+    expect(inferBump([cs({}), cs({}, 'b.md')])).toEqual({})
+  })
+
+  test('single package patch', () => {
+    expect(inferBump([cs({ a: 'patch' })])).toEqual({ a: 'patch' })
+  })
+
+  test('per-package: different bumps for different packages', () => {
+    expect(inferBump([cs({ a: 'patch' }), cs({ b: 'minor' }, 'b.md')])).toEqual({
+      a: 'patch',
+      b: 'minor',
+    })
+  })
+
+  test('same package across changesets → highest wins', () => {
+    expect(inferBump([cs({ a: 'patch' }), cs({ a: 'minor' }, 'b.md')])).toEqual({ a: 'minor' })
+  })
+
+  test('mixed bumps within a single changeset', () => {
+    expect(inferBump([cs({ a: 'minor', b: 'major' })])).toEqual({ a: 'minor', b: 'major' })
+  })
+
+  test('complex: multiple changesets, multiple packages, highest per-package', () => {
+    expect(
+      inferBump([cs({ a: 'patch', b: 'minor' }), cs({ a: 'major', c: 'patch' }, 'b.md')]),
+    ).toEqual({ a: 'major', b: 'minor', c: 'patch' })
+  })
+})
+
+describe('parseTagVersion', () => {
+  test('v0.2.3 → 0.2.3', () => {
+    expect(parseTagVersion('v0.2.3')).toBe('0.2.3')
+  })
+
+  test('0.2.3 → 0.2.3', () => {
+    expect(parseTagVersion('0.2.3')).toBe('0.2.3')
+  })
+
+  test('v1.0.0-rc.1 → 1.0.0-rc.1', () => {
+    expect(parseTagVersion('v1.0.0-rc.1')).toBe('1.0.0-rc.1')
+  })
+
+  test('throws on invalid tag', () => {
+    expect(() => parseTagVersion('release-foo')).toThrow(/invalid tag/i)
+    expect(() => parseTagVersion('')).toThrow(/invalid tag/i)
+  })
+})

package/tests/workflow-schema.test.ts

@@ -0,0 +1,72 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { describe, expect, test } from 'vitest'
+import { parse as parseYAML } from 'yaml'
+
+describe('Issue #154: already_approved variant in review-pr.yaml', () => {
+  const reviewPrPath = resolve(__dirname, '../../../.workflows/review-pr.yaml')
+
+  test('T154.1: already_approved variant does NOT include selfReview (synced with uwf)', () => {
+    const yaml = readFileSync(reviewPrPath, 'utf8')
+    const parsed = parseYAML(yaml)
+    const alreadyApproved = parsed.roles.fetcher.frontmatter.oneOf[1]
+
+    expect(alreadyApproved.properties.selfReview).toBeUndefined()
+  })
+
+  test('T154.2: already_approved variant requires only $status, repo, prNumber', () => {
+    const yaml = readFileSync(reviewPrPath, 'utf8')
+    const parsed = parseYAML(yaml)
+    const alreadyApproved = parsed.roles.fetcher.frontmatter.oneOf[1]
+
+    expect(alreadyApproved.required).not.toContain('selfReview')
+    expect(alreadyApproved.required).toEqual(['$status', 'repo', 'prNumber'])
+  })
+
+  test('T154.3: ready variant maintains selfReview field (regression)', () => {
+    const yaml = readFileSync(reviewPrPath, 'utf8')
+    const parsed = parseYAML(yaml)
+    const ready = parsed.roles.fetcher.frontmatter.oneOf[0]
+
+    expect(ready.properties.selfReview).toBeDefined()
+    expect(ready.properties.selfReview.type).toBe('boolean')
+    expect(ready.required).toContain('selfReview')
+  })
+})
+
+describe('Issue #156: Token retrieval in triage-issues.yaml', () => {
+  const triageIssuesPath = resolve(__dirname, '../../../.workflows/triage-issues.yaml')
+
+  test('T156.1: output section documents cfg get GITEA_TOKEN', () => {
+    const yaml = readFileSync(triageIssuesPath, 'utf8')
+    const parsed = parseYAML(yaml)
+    const output = parsed.roles.triager.output
+
+    // The output instruction mentions cfg-based token retrieval
+    expect(output).toBeDefined()
+  })
+
+  test('T156.4: owner/repo sed extraction remains unchanged', () => {
+    const yaml = readFileSync(triageIssuesPath, 'utf8')
+    const parsed = parseYAML(yaml)
+    const procedure = parsed.roles.triager.procedure
+
+    // This sed pattern should remain (only token extraction is changing)
+    expect(procedure).toContain(
+      "git remote get-url origin | sed 's/.*[:/]\\([^/]*\\/[^.]*\\).*/\\1/'",
+    )
+  })
+})
+
+describe('Integration tests', () => {
+  test('T157.1: both workflow files parse as valid YAML', () => {
+    const reviewPrPath = resolve(__dirname, '../../../.workflows/review-pr.yaml')
+    const triageIssuesPath = resolve(__dirname, '../../../.workflows/triage-issues.yaml')
+
+    const reviewPr = readFileSync(reviewPrPath, 'utf8')
+    const triageIssues = readFileSync(triageIssuesPath, 'utf8')
+
+    expect(() => parseYAML(reviewPr)).not.toThrow()
+    expect(() => parseYAML(triageIssues)).not.toThrow()
+  })
+})

package/tests/workspace.test.ts

@@ -0,0 +1,160 @@
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import {
+  applyWorkspaceRewrites,
+  type PkgManifest,
+  rewriteWorkspaceDeps,
+} from '../src/utils/workspace.ts'
+
+describe('rewriteWorkspaceDeps', () => {
+  test('rewrites workspace:* in dependencies', () => {
+    const a: PkgManifest = { name: 'A', version: '1.0.0', dependencies: { B: 'workspace:*' } }
+    const b: PkgManifest = { name: 'B', version: '2.3.4' }
+    const { rewritten, unresolved } = rewriteWorkspaceDeps([a, b])
+    expect(rewritten[0]?.dependencies?.B).toBe('2.3.4')
+    expect(unresolved).toEqual([])
+  })
+
+  test('rewrites workspace:* in devDependencies', () => {
+    const a: PkgManifest = { name: 'A', version: '1.0.0', devDependencies: { B: 'workspace:*' } }
+    const b: PkgManifest = { name: 'B', version: '2.3.4' }
+    const { rewritten } = rewriteWorkspaceDeps([a, b])
+    expect(rewritten[0]?.devDependencies?.B).toBe('2.3.4')
+  })
+
+  test('leaves non workspace:* deps untouched', () => {
+    const a: PkgManifest = {
+      name: 'A',
+      version: '1.0.0',
+      dependencies: {
+        x: '^1.2.3',
+        y: '1.0.0',
+        z: 'npm:foo@1',
+        w: 'file:../x',
+      },
+    }
+    const { rewritten } = rewriteWorkspaceDeps([a])
+    expect(rewritten[0]?.dependencies).toEqual({
+      x: '^1.2.3',
+      y: '1.0.0',
+      z: 'npm:foo@1',
+      w: 'file:../x',
+    })
+  })
+
+  test('leaves unknown workspace:* and reports unresolved', () => {
+    const a: PkgManifest = {
+      name: 'A',
+      version: '1.0.0',
+      dependencies: { unknown: 'workspace:*' },
+    }
+    const b: PkgManifest = { name: 'B', version: '2.3.4' }
+    const { rewritten, unresolved } = rewriteWorkspaceDeps([a, b])
+    expect(rewritten[0]?.dependencies?.unknown).toBe('workspace:*')
+    expect(unresolved).toEqual([{ pkg: 'A', dep: 'unknown' }])
+  })
+
+  test('does not mutate input objects', () => {
+    const a: PkgManifest = { name: 'A', version: '1.0.0', dependencies: { B: 'workspace:*' } }
+    const b: PkgManifest = { name: 'B', version: '2.3.4' }
+    const aSnap = JSON.parse(JSON.stringify(a))
+    const bSnap = JSON.parse(JSON.stringify(b))
+    rewriteWorkspaceDeps([a, b])
+    expect(a).toEqual(aSnap)
+    expect(b).toEqual(bSnap)
+  })
+
+  test('handles missing dependencies / devDependencies fields', () => {
+    const a: PkgManifest = { name: 'A', version: '1.0.0' }
+    const { rewritten } = rewriteWorkspaceDeps([a])
+    expect(rewritten[0]).not.toHaveProperty('dependencies')
+    expect(rewritten[0]).not.toHaveProperty('devDependencies')
+  })
+
+  test('preserves unrelated fields', () => {
+    const a: PkgManifest = {
+      name: 'A',
+      version: '1.0.0',
+      scripts: { build: 'tsc' },
+      description: 'desc',
+      license: 'MIT',
+      dependencies: { B: 'workspace:*' },
+    }
+    const b: PkgManifest = { name: 'B', version: '2.3.4' }
+    const { rewritten } = rewriteWorkspaceDeps([a, b])
+    expect(rewritten[0]?.scripts).toEqual({ build: 'tsc' })
+    expect(rewritten[0]?.description).toBe('desc')
+    expect(rewritten[0]?.license).toBe('MIT')
+  })
+})
+
+describe('applyWorkspaceRewrites', () => {
+  let tmp: string
+
+  beforeEach(async () => {
+    tmp = await mkdtemp(join(tmpdir(), 'proman-ws-'))
+  })
+
+  afterEach(async () => {
+    await rm(tmp, { recursive: true, force: true })
+  })
+
+  test('writes 2-space indent + trailing newline', async () => {
+    await mkdir(join(tmp, 'packages/a'), { recursive: true })
+    await mkdir(join(tmp, 'packages/b'), { recursive: true })
+    const aPkg = { name: 'pkg-a', version: '0.2.0', dependencies: { 'pkg-b': 'workspace:*' } }
+    const bPkg = { name: 'pkg-b', version: '0.2.0' }
+    await writeFile(join(tmp, 'packages/a/package.json'), JSON.stringify(aPkg))
+    await writeFile(join(tmp, 'packages/b/package.json'), JSON.stringify(bPkg))
+
+    await applyWorkspaceRewrites(tmp, [
+      { name: 'pkg-a', path: 'packages/a' },
+      { name: 'pkg-b', path: 'packages/b' },
+    ])
+
+    const aText = await readFile(join(tmp, 'packages/a/package.json'), 'utf8')
+    expect(aText.endsWith('\n')).toBe(true)
+    expect(aText).toMatch(/^ {2}"/m)
+    const aParsed = JSON.parse(aText)
+    expect(aParsed.dependencies['pkg-b']).toBe('0.2.0')
+  })
+
+  test('returns only files actually changed', async () => {
+    await mkdir(join(tmp, 'packages/a'), { recursive: true })
+    await mkdir(join(tmp, 'packages/b'), { recursive: true })
+    const aPkg = { name: 'pkg-a', version: '0.2.0', dependencies: { 'pkg-b': 'workspace:*' } }
+    const bPkg = { name: 'pkg-b', version: '0.2.0', dependencies: { other: '^1.0.0' } }
+    await writeFile(join(tmp, 'packages/a/package.json'), JSON.stringify(aPkg))
+    const bText = JSON.stringify(bPkg)
+    await writeFile(join(tmp, 'packages/b/package.json'), bText)
+    const bBefore = await readFile(join(tmp, 'packages/b/package.json'))
+
+    const changed = await applyWorkspaceRewrites(tmp, [
+      { name: 'pkg-a', path: 'packages/a' },
+      { name: 'pkg-b', path: 'packages/b' },
+    ])
+
+    expect(changed.some((p) => p.includes('packages/a/package.json'))).toBe(true)
+    expect(changed.some((p) => p.includes('packages/b/package.json'))).toBe(false)
+    const bAfter = await readFile(join(tmp, 'packages/b/package.json'))
+    expect(bAfter.equals(bBefore)).toBe(true)
+  })
+
+  test('errors when a package.json is missing', async () => {
+    await mkdir(join(tmp, 'packages/a'), { recursive: true })
+    await writeFile(
+      join(tmp, 'packages/a/package.json'),
+      JSON.stringify({ name: 'pkg-a', version: '0.2.0' }),
+    )
+    await expect(
+      applyWorkspaceRewrites(tmp, [
+        { name: 'pkg-a', path: 'packages/a' },
+        { name: 'pkg-missing', path: 'packages/missing' },
+      ]),
+    ).rejects.toThrow(/packages\/missing/)
+    // also confirm a file is required
+    await stat(join(tmp, 'packages/a/package.json'))
+  })
+})

package/tsconfig.build.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "noEmit": false,
+    "moduleResolution": "node",
+    "allowImportingTsExtensions": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.integration.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/commands/bump.ts","./src/commands/deploy.ts","./src/commands/dev.ts","./src/commands/index.ts","./src/commands/init.integration.test.ts","./src/commands/init.test.ts","./src/commands/init.ts","./src/commands/link.ts","./src/commands/publish.ts","./src/config/index.ts","./src/config/load-config.ts","./src/config/types.ts","./src/config/validate-config.ts","./src/utils/changeset.ts","./src/utils/fingerprint.ts","./src/utils/git.ts","./src/utils/index.ts","./src/utils/npm.ts","./src/utils/smoke-test.ts","./src/utils/version.ts","./src/utils/workspace.ts"],"version":"5.9.3"}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+})