@shazhou/proman-core 0.9.0

package/dist/utils/npm.js

@@ -0,0 +1,85 @@
+const RELEASE_BRANCH_RE = /^release\/(.+)$/;
+export function parseReleaseBranch(branch) {
+    const m = branch.match(RELEASE_BRANCH_RE);
+    if (!m)
+        throw new Error(`not a release branch: '${branch}'`);
+    const v = m[1].trim();
+    if (!v)
+        throw new Error(`malformed release branch: '${branch}'`);
+    return v;
+}
+export function nextRcNumber(opts) {
+    const { baseVersion, existing } = opts;
+    const prefix = `${baseVersion}-rc.`;
+    let max = 0;
+    for (const v of existing) {
+        if (!v.startsWith(prefix))
+            continue;
+        const tail = v.slice(prefix.length);
+        const n = Number.parseInt(tail, 10);
+        if (Number.isFinite(n) && n > max)
+            max = n;
+    }
+    return max + 1;
+}
+export function formatRcVersion(baseVersion, n) {
+    return `${baseVersion}-rc.${n}`;
+}
+export const defaultRegistryFetch = async (pkg) => {
+    const res = await fetch(`https://registry.npmjs.org/${pkg}`);
+    if (!res.ok) {
+        if (res.status === 404)
+            return [];
+        throw new Error(`registry fetch failed for ${pkg}: ${res.status} ${res.statusText}`);
+    }
+    const json = (await res.json());
+    return Object.keys(json.versions ?? {});
+};
+export const defaultSpawn = async (argv, cwd) => {
+    const { spawnSync } = await import('node:child_process');
+    const result = spawnSync(argv[0], argv.slice(1), {
+        cwd,
+        stdio: 'pipe',
+    });
+    const stdout = result.stdout?.toString() ?? '';
+    const stderr = result.stderr?.toString() ?? '';
+    // Forward captured output to terminal so users still see progress
+    if (stdout)
+        process.stdout.write(stdout);
+    if (stderr)
+        process.stderr.write(stderr);
+    return {
+        code: result.status ?? 1,
+        stdout,
+        stderr,
+    };
+};
+export async function runOrThrow(spawn, argv, cwd) {
+    const { code, stdout, stderr } = await spawn(argv, cwd);
+    if (code !== 0) {
+        const detail = stderr.trim() || stdout.trim();
+        throw new Error(detail ? `${argv.join(' ')} failed: ${detail}` : `${argv.join(' ')} failed`);
+    }
+}
+export function createNpmRunner(cwd, spawn = defaultSpawn) {
+    const runScript = (script) => async () => {
+        await runOrThrow(spawn, ['pnpm', 'run', script], cwd);
+    };
+    return {
+        install: async () => {
+            await runOrThrow(spawn, ['pnpm', 'install'], cwd);
+        },
+        build: runScript('build'),
+        test: async () => {
+            await runOrThrow(spawn, ['pnpm', 'exec', 'vitest', 'run'], cwd);
+        },
+        check: runScript('check'),
+        format: runScript('format'),
+        publish: async (pkgDir, opts) => {
+            const args = ['pnpm', 'publish', '--tag', opts.tag, '--no-git-checks'];
+            if (opts.access)
+                args.push('--access', opts.access);
+            await runOrThrow(spawn, args, pkgDir);
+        },
+    };
+}

package/dist/utils/smoke-test.d.ts

@@ -0,0 +1,7 @@
+import type { SpawnFn } from './npm.js';
+/**
+ * Smoke test a package tarball by extracting it and running bin commands.
+ * Validates that the packaged artifact actually works before publishing.
+ */
+export declare function smokeTestTarball(pkgDir: string, spawn: SpawnFn): Promise<void>;
+//# sourceMappingURL=smoke-test.d.ts.map

package/dist/utils/smoke-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoke-test.d.ts","sourceRoot":"","sources":["../../src/utils/smoke-test.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAQvC;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA+DpF"}

package/dist/utils/smoke-test.js

@@ -0,0 +1,59 @@
+import { readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * 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, spawn) {
+    // 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);
+    // Skip if no bin entry
+    if (!pkgJson.bin) {
+        return;
+    }
+    // Normalize bin to Record format
+    const binEntries = 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/dist/utils/version.d.ts

@@ -0,0 +1,5 @@
+import type { Bump, Changeset } from './changeset.js';
+export declare function bumpVersion(current: string, bump: Bump): string;
+export declare function inferBump(changesets: Changeset[]): Record<string, Bump>;
+export declare function parseTagVersion(tag: string): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/utils/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/utils/version.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAIrD,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAW/D;AAID,wBAAgB,SAAS,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAWvE;AAID,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMnD"}

package/dist/utils/version.js

@@ -0,0 +1,36 @@
+const VERSION_CORE_RE = /^(\d+)\.(\d+)\.(\d+)(?:-[\w.+-]+)?$/;
+export function bumpVersion(current, bump) {
+    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 = { patch: 1, minor: 2, major: 3 };
+export function inferBump(changesets) {
+    const result = {};
+    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) {
+    const m = tag.match(TAG_RE);
+    if (!m) {
+        throw new Error(`invalid tag: '${tag}'`);
+    }
+    return m[1];
+}

package/dist/utils/workspace.d.ts

@@ -0,0 +1,21 @@
+export type PkgManifest = {
+    name: string;
+    version: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    [k: string]: unknown;
+};
+type Unresolved = {
+    pkg: string;
+    dep: string;
+};
+export declare function rewriteWorkspaceDeps(manifests: PkgManifest[]): {
+    rewritten: PkgManifest[];
+    unresolved: Unresolved[];
+};
+export declare function applyWorkspaceRewrites(rootDir: string, packages: {
+    name: string;
+    path: string;
+}[]): Promise<string[]>;
+export {};
+//# sourceMappingURL=workspace.d.ts.map

package/dist/utils/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/utils/workspace.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB,CAAA;AAED,KAAK,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AA8B9C,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG;IAC9D,SAAS,EAAE,WAAW,EAAE,CAAA;IACxB,UAAU,EAAE,UAAU,EAAE,CAAA;CACzB,CAiBA;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GACzC,OAAO,CAAC,MAAM,EAAE,CAAC,CA2BnB"}

package/dist/utils/workspace.js

@@ -0,0 +1,73 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+function rewriteDepsField(pkgName, field, versions, unresolved) {
+    if (!field)
+        return undefined;
+    const out = {};
+    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) {
+    const versions = new Map();
+    for (const m of manifests) {
+        versions.set(m.name, m.version);
+    }
+    const unresolved = [];
+    const rewritten = manifests.map((m) => {
+        const copy = { ...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, packages) {
+    const paths = packages.map((p) => resolve(rootDir, p.path, 'package.json'));
+    const manifests = [];
+    for (let i = 0; i < paths.length; i++) {
+        const p = paths[i];
+        let text;
+        try {
+            text = await readFile(p, 'utf8');
+        }
+        catch (err) {
+            throw new Error(`package.json not found at ${p}: ${err.message}`);
+        }
+        manifests.push(JSON.parse(text));
+    }
+    const { rewritten } = rewriteWorkspaceDeps(manifests);
+    const changed = [];
+    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];
+            const newText = `${JSON.stringify(rewritten[i], null, 2)}\n`;
+            await writeFile(p, newText);
+            changed.push(p);
+        }
+    }
+    return changed;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@shazhou/proman-core",
+  "version": "0.9.0",
+  "type": "module",
+  "description": "Core library for TypeScript monorepo management",
+  "keywords": [
+    "typescript",
+    "monorepo",
+    "build",
+    "library"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./commands": "./dist/commands/index.js",
+    "./utils": "./dist/utils/index.js",
+    "./config": "./dist/config/index.js"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.0"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  },
+  "peerDependencies": {
+    "@biomejs/biome": "^2.0.0",
+    "typescript": "^5.0.0",
+    "vite": "^6.0.0",
+    "vitest": "^4.0.0",
+    "wrangler": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "wrangler": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "build": "tsc --project tsconfig.build.json"
+  }
+}

package/src/commands/bump.ts

@@ -0,0 +1,131 @@
+import { readFile, stat, unlink, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { loadConfig } from '../config/load-config.js'
+import {
+  buildChangelogEntry,
+  type Changeset,
+  prependChangelog,
+  readChangesets,
+} from '../utils/changeset.js'
+import { bumpVersion, inferBump } from '../utils/version.js'
+
+export type BumpOptions = {
+  type?: 'major' | 'minor' | 'patch'
+  cwd?: string
+  now?: () => Date
+}
+
+async function readJson(path: string): Promise<Record<string, unknown>> {
+  const text = await readFile(path, 'utf8')
+  return JSON.parse(text) as Record<string, unknown>
+}
+
+async function writeJson(path: string, data: Record<string, unknown>): Promise<void> {
+  await writeFile(path, `${JSON.stringify(data, null, 2)}\n`)
+}
+
+function formatDate(d: Date): string {
+  const y = d.getUTCFullYear()
+  const m = String(d.getUTCMonth() + 1).padStart(2, '0')
+  const day = String(d.getUTCDate()).padStart(2, '0')
+  return `${y}-${m}-${day}`
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await stat(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Bump package versions independently.
+ * --type: bump all packages with the given type.
+ * No --type: infer per-package bumps from changesets; only bump packages mentioned in changesets.
+ * Returns a map of package name → new version.
+ */
+export async function bump(opts: BumpOptions = {}): Promise<Record<string, string>> {
+  const cwd = opts.cwd ?? process.cwd()
+  const now = opts.now ?? (() => new Date())
+  const cfg = loadConfig(cwd)
+
+  const bumped: Record<string, string> = {}
+
+  if (opts.type) {
+    // Explicit --type: bump all packages
+    for (const pkg of cfg.packages) {
+      const pkgPath = resolve(cwd, pkg.path, 'package.json')
+      const json = await readJson(pkgPath)
+      const current = json.version as string
+      if (!current) throw new Error(`missing version in ${pkgPath}`)
+      const version = bumpVersion(current, opts.type)
+      json.version = version
+      await writeJson(pkgPath, json)
+      bumped[pkg.name] = version
+    }
+  } else {
+    // Infer from changesets: per-package independent bump
+    const changesets = await readChangesets(cwd)
+    if (changesets.length === 0) {
+      throw new Error('no --type specified and no pending changesets found')
+    }
+    const bumpMap = inferBump(changesets)
+    if (Object.keys(bumpMap).length === 0) {
+      throw new Error('no inferable bump from changeset entries')
+    }
+
+    const pkgByName = new Map(cfg.packages.map((p) => [p.name, p]))
+
+    for (const [pkgName, bumpType] of Object.entries(bumpMap)) {
+      const pkg = pkgByName.get(pkgName)
+      if (!pkg) continue // changeset mentions unknown package, skip
+      const pkgPath = resolve(cwd, pkg.path, 'package.json')
+      const json = await readJson(pkgPath)
+      const current = json.version as string
+      if (!current) throw new Error(`missing version in ${pkgPath}`)
+      const version = bumpVersion(current, bumpType)
+      json.version = version
+      await writeJson(pkgPath, json)
+      bumped[pkgName] = version
+    }
+
+    // Generate CHANGELOG.md per bumped package
+    const date = formatDate(now())
+    const byPackage: Record<string, Changeset[]> = {}
+    for (const cs of changesets) {
+      for (const pkg of Object.keys(cs.packages)) {
+        if (!pkgByName.has(pkg)) continue
+        const arr = byPackage[pkg] ?? []
+        arr.push(cs)
+        byPackage[pkg] = arr
+      }
+    }
+
+    for (const [pkgName, version] of Object.entries(bumped)) {
+      const list = byPackage[pkgName]
+      if (!list || list.length === 0) continue
+      const pkg = pkgByName.get(pkgName)
+      if (!pkg) continue
+      const entry = buildChangelogEntry({
+        version,
+        date,
+        bodies: list.map((c) => c.body),
+      })
+      const path = resolve(cwd, pkg.path, 'CHANGELOG.md')
+      let existing: string | null = null
+      if (await fileExists(path)) {
+        existing = await readFile(path, 'utf8')
+      }
+      await writeFile(path, prependChangelog(existing, entry))
+    }
+
+    // Delete consumed changeset files
+    for (const cs of changesets) {
+      await unlink(cs.file)
+    }
+  }
+
+  return bumped
+}

package/src/commands/deploy.ts

@@ -0,0 +1,52 @@
+import { resolve } from 'node:path'
+import { loadConfig } from '../config/index.js'
+import { defaultSpawn, runOrThrow, type SpawnFn } from '../utils/npm.js'
+
+export type DeployCommandOptions = {
+  cwd: string
+  pkg?: string
+  env?: string
+  spawn?: SpawnFn
+}
+
+function pnpmExec(bin: string, ...args: string[]): string[] {
+  return ['pnpm', 'exec', bin, ...args]
+}
+
+export async function deploy(opts: DeployCommandOptions): Promise<void> {
+  const spawn = opts.spawn ?? defaultSpawn
+  const cwd = resolve(opts.cwd)
+  const cfg = loadConfig(cwd)
+
+  let targets = cfg.packages
+  if (opts.pkg !== undefined) {
+    const match = cfg.packages.find((p) => p.name === opts.pkg)
+    if (!match) {
+      throw new Error(`package not found: ${opts.pkg}`)
+    }
+    if (match.type !== 'webui' && match.type !== 'api') {
+      throw new Error(
+        `package ${opts.pkg} (type=${match.type}) is not deployable; cannot deploy non-webui/api packages`,
+      )
+    }
+    targets = [match]
+  } else {
+    targets = cfg.packages.filter((p) => p.type === 'webui' || p.type === 'api')
+  }
+
+  for (const pkg of targets) {
+    const pkgDir = resolve(cwd, pkg.path)
+    let argv: string[]
+    if (pkg.type === 'webui') {
+      argv = pnpmExec('wrangler', 'pages', 'deploy', 'dist')
+    } else if (pkg.type === 'api') {
+      argv = pnpmExec('wrangler', 'deploy')
+    } else {
+      continue
+    }
+    if (opts.env !== undefined) {
+      argv.push('--env', opts.env)
+    }
+    await runOrThrow(spawn, argv, pkgDir)
+  }
+}