@proteinjs/build 2.0.2 → 2.2.0

package/src/mergeToMain.ts

@@ -0,0 +1,187 @@
+import * as path from 'path';
+import { exec } from 'child_process';
+import { PackageUtil, cmd, LogColorWrapper } from '@proteinjs/util-node';
+import { Logger } from '@proteinjs/logger';
+import { primaryLogColor, secondaryLogColor } from './logColors';
+
+const cw = new LogColorWrapper();
+const logger = new Logger({ name: cw.color('workspace:', primaryLogColor) + cw.color('merge', secondaryLogColor) });
+
+/**
+ * Opt-in pre-phase for `version-workspace`: merge feature-branch work into `main` in each leaf git
+ * repo BEFORE versioning, so the release runs on main. Without the flag, behavior is unchanged —
+ * the workspace versions in place on whatever branch each repo is on (the "stay on feature
+ * branches and just bump deps" mode).
+ *
+ *   version-workspace --merge-to-main
+ *       Every leaf repo whose current branch != main merges its current branch HEAD into main.
+ *
+ *   version-workspace --merge-to-main=chat:17dda73,thought:ffdc105
+ *       Only the named repos (matched by git-repo directory name), each merged at the PINNED sha —
+ *       work pushed to the feature branch after the pin simply isn't in this release. A bare name
+ *       (no `:sha`) merges that repo's current branch HEAD.
+ *
+ * Also accepted via env: VERSION_WORKSPACE_MERGE_TO_MAIN (same syntax; `1`/`true` = bare mode).
+ *
+ * Semantics per repo: fetch; checkout main; sync with origin/main FAST-FORWARD-ONLY (never rebase
+ * — local main legitimately holds an unpushed merge commit on resume, and a rebase would
+ * linearize it; true local/origin divergence stops loudly); merge the sha with a merge commit
+ * (`--no-ff`). Already-merged shas are skipped (idempotent — safe to re-run after fixing a
+ * conflict). A conflict stops the run with the repo + conflicted files named, leaving the merge in
+ * progress in that repo for resolution; re-running continues past it. Repos are LEFT ON MAIN
+ * afterward (the feature branch itself is never modified); the workspace root/metarepos are never
+ * touched by this phase.
+ */
+export type MergeToMainSpec = { enabled: boolean; pins: Map<string, string | undefined> };
+
+export function parseMergeToMainSpec(args: string[], envValue?: string): MergeToMainSpec {
+  const pins = new Map<string, string | undefined>();
+  let enabled = false;
+
+  const consume = (value: string) => {
+    enabled = true;
+    if (value === '' || value === 'true' || value === '1') {
+      return; // bare mode: all repos at branch HEAD
+    }
+    for (const entry of value.split(',')) {
+      const trimmed = entry.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const [repo, sha] = trimmed.split(':').map((s) => s.trim());
+      pins.set(repo, sha || undefined);
+    }
+  };
+
+  for (const arg of args) {
+    if (arg === '--merge-to-main') {
+      consume('');
+    } else {
+      const match = arg.match(/^--merge-to-main=(.*)$/);
+      if (match) {
+        consume(match[1]);
+      }
+    }
+  }
+  if (!enabled && envValue) {
+    consume(envValue);
+  }
+
+  return { enabled, pins };
+}
+
+export async function mergeToMain(workspacePath: string, spec: MergeToMainSpec, planOnly: boolean): Promise<void> {
+  if (!spec.enabled) {
+    return;
+  }
+
+  const repoRoots = await leafRepoRoots(workspacePath);
+  for (const repoRoot of repoRoots) {
+    const repoName = path.basename(repoRoot);
+    const pinned = spec.pins.size > 0;
+    if (pinned && !spec.pins.has(repoName)) {
+      continue;
+    }
+    const branch = await git(repoRoot, 'rev-parse --abbrev-ref HEAD');
+    const sha = spec.pins.get(repoName) ?? (branch === 'main' ? undefined : await git(repoRoot, 'rev-parse HEAD'));
+    if (!sha) {
+      // Bare mode and already on main with no pin: nothing to merge.
+      continue;
+    }
+
+    if (planOnly) {
+      logger.info({
+        message: `(${cw.color(repoName)}) would merge ${sha.slice(0, 9)} (${branch}) into main. NOTE: plan-only bump levels below reflect PRE-merge state; run with --dry-run after merging for post-merge planning.`,
+      });
+      continue;
+    }
+
+    await cmd('git', ['fetch', '-q'], { cwd: repoRoot }, { logPrefix: `[${cw.color(repoName)}] ` });
+    try {
+      await git(repoRoot, `cat-file -e ${sha}^{commit}`);
+    } catch {
+      throw new Error(`(${repoName}) --merge-to-main sha ${sha} is not a commit in this repo`);
+    }
+
+    if (branch !== 'main') {
+      await cmd('git', ['checkout', 'main'], { cwd: repoRoot }, { logPrefix: `[${cw.color(repoName)}] ` });
+    }
+    // Sync local main with origin FAST-FORWARD-ONLY — never rebase: after a prior run of this
+    // phase, local main legitimately holds an UNPUSHED MERGE COMMIT, and a rebase would linearize
+    // it (replaying every branch commit, usually into conflicts). Ahead-of-origin is the normal
+    // resume state and is fine; true divergence (local merge AND origin moved) is abnormal —
+    // stop loudly rather than guess.
+    try {
+      await cmd(
+        'git',
+        ['merge', '--ff-only', 'origin/main'],
+        { cwd: repoRoot },
+        { logPrefix: `[${cw.color(repoName)}] ` }
+      );
+    } catch {
+      const originIsAncestor = await git(repoRoot, 'merge-base --is-ancestor origin/main HEAD')
+        .then(() => true)
+        .catch(() => false);
+      if (!originIsAncestor) {
+        throw new Error(
+          `(${repoName}) local main and origin/main have DIVERGED (local holds unpushed commits AND origin moved). ` +
+            `Reconcile manually (e.g. merge origin/main into main), then re-run.`
+        );
+      }
+      logger.info({
+        message: `(${cw.color(repoName)}) local main is ahead of origin (unpushed merge from a prior run) — continuing`,
+      });
+    }
+
+    const alreadyMerged = await git(repoRoot, `merge-base --is-ancestor ${sha} HEAD`)
+      .then(() => true)
+      .catch(() => false);
+    if (alreadyMerged) {
+      logger.info({ message: `(${cw.color(repoName)}) ${sha.slice(0, 9)} already on main — skipping merge` });
+      continue;
+    }
+
+    logger.info({ message: `(${cw.color(repoName)}) merging ${sha.slice(0, 9)} (${branch}) into main` });
+    try {
+      await cmd(
+        'git',
+        [
+          'merge',
+          '--no-ff',
+          '-m',
+          `merge: ${branch} @ ${sha.slice(0, 9)} -> main (version-workspace --merge-to-main)`,
+          sha,
+        ],
+        { cwd: repoRoot },
+        { logPrefix: `[${cw.color(repoName)}] ` }
+      );
+    } catch (error) {
+      const conflicted = await git(repoRoot, 'diff --name-only --diff-filter=U').catch(() => '');
+      throw new Error(
+        `(${repoName}) merge of ${sha.slice(0, 9)} into main has conflicts: [${conflicted.split('\n').filter(Boolean).join(', ')}]. ` +
+          `Resolve + commit the merge in ${repoRoot}, then re-run — already-merged repos are skipped.`
+      );
+    }
+  }
+}
+
+/** Unique git-repo roots that directly contain workspace packages — never the workspace root. */
+async function leafRepoRoots(workspacePath: string): Promise<string[]> {
+  const { packageMap, sortedPackageNames } = await PackageUtil.getWorkspaceMetadata(workspacePath);
+  const roots = new Set<string>();
+  for (const packageName of sortedPackageNames) {
+    const localPackage = packageMap[packageName];
+    const packageDir = path.dirname(localPackage.filePath);
+    const repoRoot = await git(packageDir, 'rev-parse --show-toplevel').catch(() => undefined);
+    if (repoRoot && path.resolve(repoRoot) !== path.resolve(workspacePath)) {
+      roots.add(repoRoot);
+    }
+  }
+  return Array.from(roots).sort();
+}
+
+function git(cwd: string, args: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    exec(`git ${args}`, { cwd }, (error, stdout) => (error ? reject(error) : resolve(stdout.trim())));
+  });
+}

package/src/versionWorkspace.ts

@@ -6,6 +6,7 @@ import semver from 'semver';
 import { Commit } from './Github';
 import { primaryLogColor, secondaryLogColor } from './logColors';
 import { hasLintConfig } from './lintWorkspace';
+import { mergeToMain, parseMergeToMainSpec } from './mergeToMain';
 
 const cw = new LogColorWrapper();
 const logger = new Logger({ name: cw.color('workspace:', primaryLogColor) + cw.color('version', secondaryLogColor) });
@@ -25,6 +26,13 @@ export async function versionWorkspace() {
   }
   const workspacePath = process.cwd();
   await evictGitLocks(workspacePath);
+
+  // Opt-in pre-phase: merge feature-branch work into main per leaf repo before versioning (see
+  // mergeToMain.ts). Default (no flag) is unchanged: version in place on each repo's current
+  // branch. Repos this phase touches are left ON MAIN; feature branches are never modified.
+  const mergeSpec = parseMergeToMainSpec(process.argv.slice(2), process.env.VERSION_WORKSPACE_MERGE_TO_MAIN);
+  await mergeToMain(workspacePath, mergeSpec, planOnly);
+
   const workspaceRootDirty = await isRepoDirty(workspacePath);
   if (workspaceRootDirty) {
     logger.info({ message: `> Workspace root is dirty, will skip pull/push for root repo` });
@@ -37,7 +45,17 @@ export async function versionWorkspace() {
 
   const { packageMap, packageGraph, sortedPackageNames, workspaceToPackageMap } =
     await PackageUtil.getWorkspaceMetadata(workspacePath);
-  const skippedPackages = ['root', 'typescript-parser'];
+  const userSkippedPackages = getUserSkippedPackages();
+  if (userSkippedPackages.size > 0) {
+    logger.info({
+      message: `> Skipping packages this run (no version/build/publish; dependents keep their current dep versions): ${Array.from(
+        userSkippedPackages
+      )
+        .map((n) => cw.color(n))
+        .join(', ')}`,
+    });
+  }
+  const skippedPackages = ['root', 'typescript-parser', ...Array.from(userSkippedPackages)];
   const filteredPackageNames = sortedPackageNames.filter((packageName) => {
     const localPackage = packageMap[packageName];
     return (
@@ -85,7 +103,12 @@ export async function versionWorkspace() {
     const localPackage = packageMap[packageName];
     const skipBumpingPackageVersion = isInFixedVersionWorkspace(localPackage);
     const ownBump = skipBumpingPackageVersion ? undefined : commitBumps.get(packageName);
-    const dependenciesChanged = await applyDependencyVersionRewrites(localPackage, packageMap, packageGraph);
+    const dependenciesChanged = await applyDependencyVersionRewrites(
+      localPackage,
+      packageMap,
+      packageGraph,
+      userSkippedPackages
+    );
     const cascadeBump: CommitBump | undefined = dependenciesChanged ? 'patch' : undefined;
     const effectiveBump = maxBump(ownBump, cascadeBump);
 
@@ -98,11 +121,7 @@ export async function versionWorkspace() {
       // In-memory version mutation runs in plan-only too so downstream
       // packages see the right dep versions when we simulate cascades.
       localPackage.packageJson.version = semver.inc(currentVersion, effectiveBump);
-      const sourceNote = ownBump
-        ? cascadeBump
-          ? `own+cascade, own=${ownBump}`
-          : `own=${ownBump}`
-        : 'dep cascade';
+      const sourceNote = ownBump ? (cascadeBump ? `own+cascade, own=${ownBump}` : `own=${ownBump}`) : 'dep cascade';
       const planPrefix = planOnly ? 'would bump' : 'bumping';
       logger.info({
         message: `(${cw.color(packageName)}) ${planPrefix} version (${effectiveBump}; ${sourceNote}) from ${currentVersion} -> ${localPackage.packageJson.version}`,
@@ -208,6 +227,46 @@ function isPlanOnly() {
   return false;
 }
 
+/**
+ * Packages to exclude from this run entirely: not versioned, built, or
+ * published, and — critically — dependents' references to them are NOT
+ * rewritten to the on-disk version (see `applyDependencyVersionRewrites`).
+ *
+ * Use case: a package in the workspace has shipped a breaking new major
+ * (already published and checked out locally) but its consumers haven't been
+ * migrated yet. Skipping it lets the rest of the workspace version and deploy
+ * while consumers stay pinned to the version they were built against.
+ *
+ * Accepts `--skip=<name>[,<name>...]` (repeatable) or the
+ * VERSION_WORKSPACE_SKIP env var, e.g.:
+ *   version-workspace --skip=@proteinjs/conversation
+ */
+function getUserSkippedPackages(): Set<string> {
+  const skipped = new Set<string>();
+  const args = process.argv.slice(2);
+  for (const arg of args) {
+    const match = arg.match(/^--skip=(.+)$/);
+    if (match) {
+      match[1]
+        .split(',')
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0)
+        .forEach((name) => skipped.add(name));
+    }
+  }
+
+  const envFlag = process.env.VERSION_WORKSPACE_SKIP;
+  if (envFlag) {
+    envFlag
+      .split(',')
+      .map((name) => name.trim())
+      .filter((name) => name.length > 0)
+      .forEach((name) => skipped.add(name));
+  }
+
+  return skipped;
+}
+
 function isInFixedVersionWorkspace(localPackage: LocalPackage) {
   return (
     localPackage.workspace &&
@@ -280,7 +339,8 @@ async function pullWorkspace(workspacePath: string, skipRootRepo = false) {
 async function applyDependencyVersionRewrites(
   localPackage: LocalPackage,
   packageMap: LocalPackageMap,
-  packageGraph: any
+  packageGraph: any,
+  userSkippedPackages: Set<string> = new Set()
 ): Promise<boolean> {
   const localDependencies = packageGraph.successors(localPackage.name);
   if (!localDependencies || localDependencies.length == 0) {
@@ -306,6 +366,16 @@ async function applyDependencyVersionRewrites(
       continue;
     }
 
+    if (userSkippedPackages.has(localDependency)) {
+      // The dep was skipped via --skip: leave this package's reference at its
+      // current (published, known-compatible) version instead of rewriting to
+      // the on-disk version of the skipped package.
+      logger.info({
+        message: `(${cw.color(localPackage.name)}) keeping dependency version of ${cw.color(localDependency)} at ${currentDependencyVersion.prefix ?? ''}${currentDependencyVersion.version} (skipped via --skip; on-disk is ${localDependencyVersion})`,
+      });
+      continue;
+    }
+
     const newDependencyVersion: DependencyVersion = {
       prefix: currentDependencyVersion.prefix,
       version: localDependencyVersion,
@@ -326,10 +396,7 @@ async function applyDependencyVersionRewrites(
  * This is the input to `computeCommitLeaves` and to the per-package bump-level
  * combine in the main loop.
  */
-async function scanCommitBumps(
-  packageNames: string[],
-  packageMap: LocalPackageMap
-): Promise<Map<string, CommitBump>> {
+async function scanCommitBumps(packageNames: string[], packageMap: LocalPackageMap): Promise<Map<string, CommitBump>> {
   const result = new Map<string, CommitBump>();
   for (const packageName of packageNames) {
     const localPackage = packageMap[packageName];
@@ -845,7 +912,13 @@ async function publish(localPackage: LocalPackage) {
   }
 
   await retryOnNetworkError(
-    () => cmd('npm', args, { cwd: packageDir, env: { ...process.env } }, { logPrefix: `[${cw.color(localPackage.name)}] ` }),
+    () =>
+      cmd(
+        'npm',
+        args,
+        { cwd: packageDir, env: { ...process.env } },
+        { logPrefix: `[${cw.color(localPackage.name)}] ` }
+      ),
     localPackage.name,
     3,
     15_000
@@ -991,7 +1064,10 @@ export async function classifyUnpushedCommits(dir: string): Promise<CommitBump |
         resolve(undefined);
         return;
       }
-      const commits = stdout.split('\x00').map((s) => s.trim()).filter((s) => s.length > 0);
+      const commits = stdout
+        .split('\x00')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
       let result: CommitBump | undefined;
       for (const commit of commits) {
         result = maxBump(result, classifyCommitMessage(commit));
@@ -1048,8 +1124,12 @@ export async function evictGitLocks(workspacePath: string) {
 function isNetworkError(error: any): boolean {
   const output = `${error.stdout ?? ''}${error.stderr ?? ''}`;
   return (
-    /ECONNRESET/i.test(output) || /ETIMEDOUT/i.test(output) || /ENOTFOUND/i.test(output) ||
-    /EAI_AGAIN/i.test(output) || /ECONNREFUSED/i.test(output) || /socket hang up/i.test(output) ||
+    /ECONNRESET/i.test(output) ||
+    /ETIMEDOUT/i.test(output) ||
+    /ENOTFOUND/i.test(output) ||
+    /EAI_AGAIN/i.test(output) ||
+    /ECONNREFUSED/i.test(output) ||
+    /socket hang up/i.test(output) ||
     /network/i.test(output)
   );
 }

package/test/parseMergeToMainSpec.test.ts

@@ -0,0 +1,43 @@
+import { parseMergeToMainSpec } from '../src/mergeToMain';
+
+describe('parseMergeToMainSpec', () => {
+  it('is disabled with no flag and no env', () => {
+    expect(parseMergeToMainSpec([]).enabled).toBe(false);
+    expect(parseMergeToMainSpec(['--dry-run']).enabled).toBe(false);
+  });
+
+  it('bare flag enables merge for all repos at branch HEAD', () => {
+    const spec = parseMergeToMainSpec(['--merge-to-main']);
+    expect(spec.enabled).toBe(true);
+    expect(spec.pins.size).toBe(0);
+  });
+
+  it('pinned form names repos with shas', () => {
+    const spec = parseMergeToMainSpec(['--merge-to-main=chat:17dda73,thought:ffdc105']);
+    expect(spec.enabled).toBe(true);
+    expect(spec.pins.get('chat')).toBe('17dda73');
+    expect(spec.pins.get('thought')).toBe('ffdc105');
+    expect(spec.pins.has('flow')).toBe(false);
+  });
+
+  it('bare repo name (no sha) pins the repo at its branch HEAD', () => {
+    const spec = parseMergeToMainSpec(['--merge-to-main=chat,thought:abc123']);
+    expect(spec.pins.has('chat')).toBe(true);
+    expect(spec.pins.get('chat')).toBeUndefined();
+    expect(spec.pins.get('thought')).toBe('abc123');
+  });
+
+  it('repeatable flags accumulate pins', () => {
+    const spec = parseMergeToMainSpec(['--merge-to-main=chat:a', '--merge-to-main=flow:b']);
+    expect(spec.pins.get('chat')).toBe('a');
+    expect(spec.pins.get('flow')).toBe('b');
+  });
+
+  it('env var enables when no flag is present; flag wins over env', () => {
+    expect(parseMergeToMainSpec([], '1').enabled).toBe(true);
+    expect(parseMergeToMainSpec([], 'chat:abc').pins.get('chat')).toBe('abc');
+    const flagWins = parseMergeToMainSpec(['--merge-to-main=flow:x'], 'chat:abc');
+    expect(flagWins.pins.has('chat')).toBe(false);
+    expect(flagWins.pins.get('flow')).toBe('x');
+  });
+});