relacher 0.0.4-rc.2 → 0.0.4-rc.3

package/lib-types/builder/cargo.d.ts

@@ -1,4 +1,9 @@
 import { type DependencyList } from './shared';
+declare module './shared' {
+    interface DependencyList {
+        couple(a: string, b: string): this;
+    }
+}
 export interface CargoBuilderOptions {
     syncWorkspaceDeps?: boolean;
 }

package/lib-types/prepare.d.ts

@@ -9,6 +9,7 @@ export declare function matchBumpSize(message: string, sizes: SizePatterns): Bum
 export declare function evaluateCommitsBump(commits: Commit[], sizes: SizePatterns): BumpSize;
 export declare function topologicalSort(items: IntermediateReport[]): IntermediateReport[];
 export declare function propagateBumps(sorted: IntermediateReport[], rules?: CascadeRules): void;
+export declare function propagateCoupledBumps(sorted: IntermediateReport[]): void;
 export declare function initReportItems(cargoDeps: DependencyConfig[], vcs: VcsProvider, sizes: SizePatterns, cwd: string): Promise<IntermediateReport[]>;
 export declare function prepare(cargoDeps: DependencyConfig[], vcs: VcsProvider, options?: PrepareOptions): Promise<DependencyUpdateReport[]>;
 export declare function finalizeReports(sorted: IntermediateReport[]): DependencyUpdateReport[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relacher",
-  "version": "0.0.4-rc.2",
+  "version": "0.0.4-rc.3",
   "description": "Scriptable release orchestration library for monorepos",
   "type": "module",
   "private": false,

package/src/builder/cargo.ts

@@ -8,6 +8,12 @@ import { tomlUpdate, tomlFallback } from '../updater';
 
 import { decorateList, type DependencyList } from './shared';
 
+declare module './shared' {
+  interface DependencyList {
+    couple(a: string, b: string): this;
+  }
+}
+
 export interface CargoBuilderOptions {
   syncWorkspaceDeps?: boolean;
 }
@@ -237,22 +243,41 @@ function buildCrateConfig(
   };
 }
 
+function coupleConfigs(configs: any[], a: string, b: string): boolean {
+  const itemA = configs.find((d) => d.name === a);
+  const itemB = configs.find((d) => d.name === b);
+  if (itemA && itemB) {
+    itemA.coupled = itemA.coupled || [];
+    itemB.coupled = itemB.coupled || [];
+    if (!itemA.coupled.includes(b)) itemA.coupled.push(b);
+    if (!itemB.coupled.includes(a)) itemB.coupled.push(a);
+  }
+  return true;
+}
+
+function scanWorkspace(workspaceRoot: string, rootDoc: any): CrateScanner {
+  const scanner = new CrateScanner(workspaceRoot, rootDoc.workspace?.dependencies || {});
+  if (rootDoc.workspace) registerWorkspaceMembers(scanner, rootDoc);
+  else if (rootDoc.package?.name) scanner.registerCrate(workspaceRoot);
+  runRecursiveDiscovery(scanner);
+  return scanner;
+}
+
 export function cargoDeps(cwd: string, options?: CargoBuilderOptions): DependencyList {
   const workspaceRoot = findCargoWorkspaceRoot(cwd);
   const rootCargo = path.join(workspaceRoot, 'Cargo.toml');
   if (!fs.existsSync(rootCargo)) return decorateList([]);
   try {
     const rootDoc = parse(fs.readFileSync(rootCargo, 'utf8')) as any;
-    const scanner = new CrateScanner(workspaceRoot, rootDoc.workspace?.dependencies || {});
-    if (rootDoc.workspace) registerWorkspaceMembers(scanner, rootDoc);
-    else if (rootDoc.package?.name) scanner.registerCrate(workspaceRoot);
-    runRecursiveDiscovery(scanner);
+    const scanner = scanWorkspace(workspaceRoot, rootDoc);
     const hasLock = fs.existsSync(path.join(workspaceRoot, 'Cargo.lock'));
     const localNames = new Set(scanner.crateInfos.map((c) => c.name));
     const configs = scanner.crateInfos.map((info) =>
       buildCrateConfig(info, workspaceRoot, localNames, hasLock, scanner.workspaceDeps, options),
     );
-    return decorateList(configs);
+    const list = decorateList(configs) as any;
+    list.couple = (a: string, b: string) => (coupleConfigs(configs, a, b) ? list : list);
+    return list;
   } catch {
     return decorateList([]);
   }

package/src/prepare.ts

@@ -125,6 +125,39 @@ export function propagateBumps(sorted: IntermediateReport[], rules?: CascadeRule
   }
 }
 
+export function propagateCoupledBumps(sorted: IntermediateReport[]): void {
+  const priority: Record<BumpSize, number> = { skip: 0, patch: 1, minor: 2, major: 3 };
+  const bumps: BumpSize[] = ['skip', 'patch', 'minor', 'major'];
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const item of sorted) {
+      const coupledNames = (item as any).coupled || [];
+      for (const name of coupledNames) {
+        const other = sorted.find((r) => r.name === name);
+        if (other) {
+          const maxPriority = Math.max(priority[item.bump], priority[other.bump]);
+          const targetBump = bumps[maxPriority]!;
+          if (item.bump !== targetBump) {
+            item.bump = targetBump;
+            changed = true;
+          }
+          if (other.bump !== targetBump) {
+            other.bump = targetBump;
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+
+  for (const item of sorted) {
+    item.newVersion =
+      item.bump !== 'skip' ? bumpVersion(item.currentVersion, item.bump) : item.currentVersion;
+  }
+}
+
 export async function initReportItems(
   cargoDeps: DependencyConfig[],
   vcs: VcsProvider,
@@ -165,7 +198,8 @@ export async function initReportItems(
       depends: dep.depends || [],
       isErroneous,
       isFirstRelease: isFallback,
-    });
+      coupled: (dep as any).coupled || [],
+    } as any);
   }
   return reports;
 }
@@ -180,6 +214,7 @@ export async function prepare(
   const items = await initReportItems(cargoDeps, vcs, sizes, cwd);
   const sorted = topologicalSort(items);
   propagateBumps(sorted, options.cascade);
+  propagateCoupledBumps(sorted);
   return finalizeReports(sorted);
 }
 
@@ -203,6 +238,7 @@ export function finalizeReports(sorted: IntermediateReport[]): DependencyUpdateR
     depends: item.depends,
     isErroneous: item.isErroneous,
     isFirstRelease: item.isFirstRelease,
+    coupled: (item as any).coupled || [],
   }));
 }