relacher 0.0.1 → 0.0.3

package/src/builder/cargo.ts

@@ -2,9 +2,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import type { DependencyConfig } from '../types';
+import { regexUpdate, tomlUpdate, tomlFallback } from '../updater';
 
 import { decorateList, type DependencyList } from './shared';
 
+export interface CargoBuilderOptions {
+  syncWorkspaceDeps?: boolean;
+}
+
 /**
  * Loads a single Cargo project from a target Cargo.toml.
  */
@@ -15,13 +20,14 @@ export function cargoProject(cwd: string): DependencyList {
   if (fs.existsSync(rootCargo)) {
     const fileContent = fs.readFileSync(rootCargo, 'utf8');
     const nameMatch = fileContent.match(/^name\s*=\s*"([^"]+)"/m);
-    const parsedName = nameMatch && nameMatch[1] ? nameMatch[1] : '';
+    const parsedName = nameMatch?.[1] ?? '';
     if (parsedName) {
       configs.push({
         name: parsedName,
         watch: ['.'],
         depends: [],
-        updates: [{ kind: 'toml', path: 'Cargo.toml', toml: 'package.version' }],
+        versionFallback: tomlFallback({ path: 'Cargo.toml', toml: 'package.version' }),
+        updates: [tomlUpdate({ path: 'Cargo.toml', toml: 'package.version' })],
       });
     }
   }
@@ -30,11 +36,12 @@ export function cargoProject(cwd: string): DependencyList {
 }
 
 /**
- * Loads a Cargo workspace, tracking member paths and dependency links.
+ * Loads a Cargo workspace, tracking member paths, dependency links, and recursive nested paths.
  */
-export function cargoWorkspace(cwd: string): DependencyList {
+export function cargoWorkspace(cwd: string, options?: CargoBuilderOptions): DependencyList {
   const configs: DependencyConfig[] = [];
   const rootCargo = path.join(cwd, 'Cargo.toml');
+  const discoveredPaths = new Set<string>();
 
   if (fs.existsSync(rootCargo)) {
     const content = fs.readFileSync(rootCargo, 'utf8');
@@ -44,47 +51,106 @@ export function cargoWorkspace(cwd: string): DependencyList {
       const crateInfos: { name: string; memberPath: string; content: string }[] = [];
 
       for (const member of rawMembers) {
+        if (!member) continue;
         const globPath = path.join(cwd, member);
         const cargoPaths = globPath.endsWith('*')
-          ? fs
-            .readdirSync(path.dirname(globPath))
-            .map((dir) => path.join(path.dirname(globPath), dir, 'Cargo.toml'))
+          ? fs.existsSync(path.dirname(globPath))
+            ? fs
+              .readdirSync(path.dirname(globPath))
+              .map((dir) => path.join(path.dirname(globPath), dir, 'Cargo.toml'))
+            : []
           : [path.join(globPath, 'Cargo.toml')];
 
         for (const p of cargoPaths) {
           if (fs.existsSync(p)) {
+            const memberPath = path.dirname(p);
+            discoveredPaths.add(memberPath);
             const fileContent = fs.readFileSync(p, 'utf8');
             const nameMatch = fileContent.match(/^name\s*=\s*"([^"]+)"/m);
-            const parsedName = nameMatch && nameMatch[1] ? nameMatch[1] : '';
+            const parsedName = nameMatch?.[1] ?? '';
             if (parsedName) {
               crateInfos.push({
                 name: parsedName,
-                memberPath: path.dirname(p),
+                memberPath,
+                content: fileContent,
+              });
+            }
+          }
+        }
+      }
+
+      // Discover nested packages dynamically via path dependencies
+      let i = 0;
+      while (i < crateInfos.length) {
+        const info = crateInfos[i]!;
+        const pathDepsMatch = [
+          ...info.content.matchAll(/([a-zA-Z0-9_-]+)\s*=\s*\{[^}]*path\s*=\s*"([^"]+)"/g),
+        ];
+        for (const match of pathDepsMatch) {
+          const depName = match[1];
+          const depPath = match[2];
+
+          // Verify matches are defined strings to resolve TypeScript's undefined safety warnings
+          if (typeof depName !== 'string' || typeof depPath !== 'string') {
+            continue;
+          }
+
+          const fullDepPath = path.resolve(info.memberPath, depPath);
+
+          if (!discoveredPaths.has(fullDepPath)) {
+            discoveredPaths.add(fullDepPath);
+            const cargoPath = path.join(fullDepPath, 'Cargo.toml');
+
+            if (fs.existsSync(cargoPath)) {
+              const fileContent = fs.readFileSync(cargoPath, 'utf8');
+              const nameMatch = fileContent.match(/^name\s*=\s*"([^"]+)"/m);
+              const parsedName = nameMatch?.[1] ?? depName;
+
+              crateInfos.push({
+                name: parsedName,
+                memberPath: fullDepPath,
                 content: fileContent,
               });
             }
           }
         }
+        i++;
       }
 
       for (const info of crateInfos) {
         const relativePath = path.relative(cwd, info.memberPath);
-        const relativeCargo = path.join(relativePath, 'Cargo.toml');
+        const posixRelativePath = relativePath.split(path.sep).join(path.posix.sep);
+        const relativeCargo = posixRelativePath
+          ? path.posix.join(posixRelativePath, 'Cargo.toml')
+          : 'Cargo.toml';
 
         const depends: string[] = [];
         for (const other of crateInfos) {
           if (other.name === info.name) continue;
-          const depPattern = new RegExp(`^${other.name}\\s*=`, 'm');
+          const depPattern = new RegExp(`^\\s*${other.name}\\s*=`, 'm');
           if (depPattern.test(info.content)) {
             depends.push(other.name);
           }
         }
 
+        const updates = [tomlUpdate({ path: relativeCargo, toml: 'package.version' })];
+
+        if (options?.syncWorkspaceDeps) {
+          updates.push(
+            regexUpdate({
+              path: 'Cargo.toml',
+              search: `(${info.name}\\s*=\\s*\\{[^}]*version\\s*=\\s*")[^"]+(")`,
+              replace: `$1{{version}}$2`,
+            }),
+          );
+        }
+
         configs.push({
           name: info.name,
-          watch: [relativePath],
+          watch: [posixRelativePath || '.'],
           depends,
-          updates: [{ kind: 'toml', path: relativeCargo, toml: 'package.version' }],
+          versionFallback: tomlFallback({ path: relativeCargo, toml: 'package.version' }),
+          updates,
         });
       }
     }
@@ -93,15 +159,12 @@ export function cargoWorkspace(cwd: string): DependencyList {
   return decorateList(configs);
 }
 
-/**
- * Auto-detects whether the directory corresponds to a workspace or single-project setup.
- */
-export function cargoDeps(cwd: string): DependencyList {
+export function cargoDeps(cwd: string, options?: CargoBuilderOptions): DependencyList {
   const rootCargo = path.join(cwd, 'Cargo.toml');
   if (fs.existsSync(rootCargo)) {
     const content = fs.readFileSync(rootCargo, 'utf8');
     if (content.includes('members =')) {
-      return cargoWorkspace(cwd);
+      return cargoWorkspace(cwd, options);
     }
     if (content.includes('package =') || content.match(/^name\s*=/m)) {
       return cargoProject(cwd);

package/src/builder/pnpm.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import type { DependencyConfig } from '../types';
+import { jsonUpdate, jsonFallback } from '../updater';
 
 import { decorateList, type DependencyList } from './shared';
 
@@ -21,13 +22,12 @@ export function pnpmProject(cwd: string): DependencyList {
           name: parsed.name,
           watch: ['.'],
           depends: [],
+          versionFallback: jsonFallback({ path: 'package.json', json: 'version' }),
           updates: [
-            {
-              kind: 'regex',
+            jsonUpdate({
               path: 'package.json',
-              search: '"version"\\s*:\\s*"[^"]+"',
-              replace: '"version": "{{version}}"',
-            },
+              json: 'version',
+            }),
           ],
         });
       }
@@ -114,7 +114,10 @@ export function pnpmWorkspace(cwd: string): DependencyList {
 
   for (const info of packageInfos) {
     const relativePath = path.relative(cwd, info.memberPath);
-    const relativePJson = path.join(relativePath, 'package.json');
+    const posixRelativePath = relativePath.split(path.sep).join(path.posix.sep);
+    const relativePJson = posixRelativePath
+      ? path.posix.join(posixRelativePath, 'package.json')
+      : 'package.json';
 
     const parsed = JSON.parse(info.content);
     const depends: string[] = [];
@@ -134,15 +137,14 @@ export function pnpmWorkspace(cwd: string): DependencyList {
 
     configs.push({
       name: info.name,
-      watch: [relativePath],
+      watch: [posixRelativePath || '.'],
       depends,
+      versionFallback: jsonFallback({ path: relativePJson, json: 'version' }),
       updates: [
-        {
-          kind: 'regex',
+        jsonUpdate({
           path: relativePJson,
-          search: '"version"\\s*:\\s*"[^"]+"',
-          replace: '"version": "{{version}}"',
-        },
+          json: 'version',
+        }),
       ],
     });
   }

package/src/builder/shared.ts

@@ -1,12 +1,5 @@
-import type { ChangelogUpdate, RegexUpdate, DependencyConfig, UpdateAction } from '../types';
-
-export function changelogUpdate(options: Omit<ChangelogUpdate, 'kind'>): ChangelogUpdate {
-  return { kind: 'changelog', ...options };
-}
-
-export function regexUpdate(options: Omit<RegexUpdate, 'kind'>): RegexUpdate {
-  return { kind: 'regex', ...options };
-}
+import type { DependencyConfig } from '../types';
+import type { UpdateAction } from '../updater';
 
 export class SingleDependencyBuilder {
   constructor(private config: DependencyConfig) { }

package/src/default-data.ts

@@ -0,0 +1,15 @@
+import type { CascadeRules, SizePatterns } from './types';
+
+export const defaultSizes: SizePatterns = {
+  major: { pattern: '^[a-z]+(?:\\([^)]+\\))?!:|BREAKING CHANGE' },
+  minor: { pattern: '^feat|^revert' },
+  patch: { pattern: '^fix|^build|^refactor|^nit|^style' },
+  skip: { pattern: '^release|^chore|^infra|^docs|^test|^ci|^build' },
+};
+
+export const defaultCascadeRules: Required<CascadeRules> = {
+  skip: { skip: 'skip', patch: 'patch', minor: 'patch', major: 'patch' },
+  patch: { skip: 'patch', patch: 'patch', minor: 'minor', major: 'minor' },
+  minor: { skip: 'minor', patch: 'minor', minor: 'minor', major: 'minor' },
+  major: { skip: 'major', patch: 'major', minor: 'major', major: 'major' },
+};

package/src/index.ts

@@ -4,3 +4,4 @@ export * from './vcs';
 export * from './builder';
 export * from './print';
 export * from './types';
+export * from './updater';

package/src/prepare.ts

@@ -1,28 +1,19 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import {
-  defaultSizes,
-  defaultCascadeRules,
-  type BumpSize,
-  type Commit,
-  type VcsProvider,
-  type DependencyConfig,
-  type DependencyUpdateReport,
-  type IntermediateReport,
-  type PrepareOptions,
-  type SizePatterns,
-  type CascadeRules,
-  type UpdateAction,
-  type ChangelogContext,
+import { defaultCascadeRules, defaultSizes } from './default-data';
+import type {
+  BumpSize,
+  Commit,
+  VcsProvider,
+  DependencyConfig,
+  DependencyUpdateReport,
+  IntermediateReport,
+  PrepareOptions,
+  SizePatterns,
+  CascadeRules,
 } from './types';
-
-export function getTomlValue(content: string): string | null {
-  const packageMatch = content.match(/\[package\][^]*?(?=^\[|z)/);
-  const targetText = packageMatch ? packageMatch[0] : content;
-  const versionMatch = targetText.match(/^version\s*=\s*"([^"]+)"/m);
-  return versionMatch && versionMatch[1] ? versionMatch[1] : null;
-}
+import type { UpdateAction, UpdateActionResolved } from './updater';
 
 export function bumpVersion(version: string, size: BumpSize): string {
   const parts = version.split('.').map(Number);
@@ -37,12 +28,32 @@ export function bumpVersion(version: string, size: BumpSize): string {
   return version;
 }
 
-export function getCurrentVersion(dep: DependencyConfig, cwd: string): string {
-  const tomlUpdate = dep.updates?.find((u) => u.kind === 'toml');
-  if (!tomlUpdate) return '0.0.0';
-  const filePath = path.resolve(cwd, tomlUpdate.path);
-  if (!fs.existsSync(filePath)) return '0.0.0';
-  return getTomlValue(fs.readFileSync(filePath, 'utf8')) || '0.0.0';
+export async function getCurrentVersion(
+  dep: DependencyConfig,
+  vcs: VcsProvider,
+  cwd: string,
+): Promise<{ version: string | null; isFallback: boolean }> {
+  // 1. Look for releases in git history first
+  const latestTag = await vcs.getLatestTag(dep.name);
+  if (latestTag) {
+    let version = latestTag;
+
+    // Strip package-specific prefixes (e.g., "api-v1.0.0" or "api/v1.0.0" -> "v1.0.0")
+    if (version.startsWith(`${dep.name}-`)) {
+      version = version.slice(dep.name.length + 1);
+    } else if (version.startsWith(`${dep.name}/`)) {
+      version = version.slice(dep.name.length + 1);
+    }
+
+    return { version: version.replace(/^v/, ''), isFallback: false };
+  }
+
+  // 2. Resolve via user-defined fallback
+  if (dep.versionFallback) {
+    return { version: dep.versionFallback.readFallback(cwd), isFallback: true };
+  }
+
+  return { version: null, isFallback: false };
 }
 
 export function matchBumpSize(message: string, sizes: SizePatterns): BumpSize {
@@ -125,18 +136,35 @@ export async function initReportItems(
 ): Promise<IntermediateReport[]> {
   const reports: IntermediateReport[] = [];
   for (const dep of cargoDeps) {
-    const currentVersion = getCurrentVersion(dep, cwd);
+    const { version: currentVersion, isFallback } = await getCurrentVersion(dep, vcs, cwd);
+    const isMissingVersion = currentVersion === null;
+    const actualVersion = currentVersion || '0.0.0';
+
     const commits = await vcs.getCommits(dep.name, dep.watch || []);
     const selfBump = evaluateCommitsBump(commits, sizes);
+
+    let isErroneous = isMissingVersion;
+    for (const u of dep.updates || []) {
+      if (u.required) {
+        const filePath = path.resolve(cwd, u.path);
+        if (!fs.existsSync(filePath)) {
+          isErroneous = true;
+          break;
+        }
+      }
+    }
+
     reports.push({
       name: dep.name,
-      currentVersion,
-      newVersion: currentVersion,
+      currentVersion: actualVersion,
+      newVersion: actualVersion,
       bump: selfBump,
       originalBump: selfBump,
       commits,
       updates: dep.updates || [],
       depends: dep.depends || [],
+      isErroneous,
+      isFirstRelease: isFallback,
     });
   }
   return reports;
@@ -155,39 +183,6 @@ export async function prepare(
   return finalizeReports(sorted);
 }
 
-export function buildChangelogBlock(version: string, commits: Commit[]): string {
-  const date = new Date().toISOString().split('T')[0] ?? '';
-  let block = `## [${version}] - ${date}\n\n`;
-
-  if (commits.length === 0) {
-    return block + `*No notable changes.*\n`;
-  }
-
-  const breaking: string[] = [];
-  const features: string[] = [];
-  const fixes: string[] = [];
-  const others: string[] = [];
-
-  for (const c of commits) {
-    if (c.message.includes('!:') || c.message.includes('BREAKING CHANGE')) {
-      breaking.push(`- ${c.hash} ${c.message}`);
-    } else if (c.message.startsWith('feat')) {
-      features.push(`- ${c.hash} ${c.message}`);
-    } else if (c.message.startsWith('fix')) {
-      fixes.push(`- ${c.hash} ${c.message}`);
-    } else {
-      others.push(`- ${c.hash} ${c.message}`);
-    }
-  }
-
-  if (breaking.length) block += `### ⚠️ BREAKING CHANGES\n${breaking.join('\n')}\n\n`;
-  if (features.length) block += `### ✨ Features\n${features.join('\n')}\n\n`;
-  if (fixes.length) block += `### 🐛 Bug Fixes\n${fixes.join('\n')}\n\n`;
-  if (others.length) block += `### 🛠 Other Changes\n${others.join('\n')}\n\n`;
-
-  return block.trim() + '\n';
-}
-
 export function finalizeReports(sorted: IntermediateReport[]): DependencyUpdateReport[] {
   const allCommitsMap = new Map<string, Commit>();
   for (const item of sorted) {
@@ -206,57 +201,22 @@ export function finalizeReports(sorted: IntermediateReport[]): DependencyUpdateR
     commits: item.commits,
     updates: mapResolvedUpdates(item.updates, item.newVersion, item.commits, globalCommits),
     depends: item.depends,
+    isErroneous: item.isErroneous,
+    isFirstRelease: item.isFirstRelease,
   }));
 }
 
-export function defaultChangelogTemplate({ version, date, commits }: ChangelogContext): string {
-  let block = `## [${version}] - ${date}\n\n`;
-  if (commits.length === 0) return block + `*No notable changes.*\n`;
-
-  const groups: { breaking: string[]; feat: string[]; fix: string[]; other: string[] } = {
-    breaking: [],
-    feat: [],
-    fix: [],
-    other: [],
-  };
-
-  for (const c of commits) {
-    const item = `- ${c.shortHash} ${c.message}`;
-    if (c.isBreaking) groups.breaking.push(item);
-    else if (c.type === 'feat') groups.feat.push(item);
-    else if (c.type === 'fix') groups.fix.push(item);
-    else groups.other.push(item);
-  }
-
-  if (groups.breaking.length) block += `### ⚠️ BREAKING CHANGES\n${groups.breaking.join('\n')}\n\n`;
-  if (groups.feat.length) block += `### ✨ Features\n${groups.feat.join('\n')}\n\n`;
-  if (groups.fix.length) block += `### 🐛 Bug Fixes\n${groups.fix.join('\n')}\n\n`;
-  if (groups.other.length) block += `### 🛠 Other Changes\n${groups.other.join('\n')}\n\n`;
-
-  return block.trim() + '\n';
-}
-
 export function mapResolvedUpdates(
   updates: UpdateAction[],
   newVersion: string,
   crateCommits: Commit[],
   globalCommits: Commit[],
-): UpdateAction[] {
-  return updates.map((u) => {
-    if (u.kind === 'regex') {
-      return { ...u, resolvedReplace: u.replace.replace('{{version}}', newVersion) };
-    }
-    if (u.kind === 'changelog') {
-      const targetCommits = u.global ? globalCommits : crateCommits;
-      const context: ChangelogContext = {
-        version: newVersion,
-        date: new Date().toISOString().split('T')[0] ?? '',
-        commits: targetCommits,
-      };
-
-      const content = u.template ? u.template(context) : defaultChangelogTemplate(context);
-      return { ...u, resolvedBlock: content };
-    }
-    return u;
-  });
+): UpdateActionResolved[] {
+  return updates.map((act) =>
+    act.prepare({
+      newVersion,
+      crateCommits,
+      globalCommits,
+    }),
+  );
 }

package/src/print.ts

@@ -1,5 +1,5 @@
+import { defaultSizes } from './default-data';
 import { matchBumpSize } from './prepare';
-import { defaultSizes } from './types';
 import type { DependencyUpdateReport } from './types';
 
 // ANSI Escape Codes for Terminal Colors
@@ -57,14 +57,19 @@ function getIconForFile(filename: string): string {
 
   return icons[ext] || '󰈚'; // Default file icon
 }
+
 export function prettyPrint(reports: DependencyUpdateReport[]): void {
   for (const report of reports) {
     if (report.bump === 'skip') continue;
 
     const bumpColor =
       report.bump === 'major' ? c.red : report.bump === 'minor' ? c.yellow : c.green;
+
+    // Check if it's a first release (fallback was used instead of finding tags)
+    const firstReleaseBadge = report.isFirstRelease ? ` ${c.cyan}🌱 (first release)${c.reset}` : '';
+
     process.stdout.write(
-      `${c.bold}📦 ${report.name.padEnd(12)}${c.reset} ${highlightVersion(report.currentVersion, report.newVersion)} ${bumpColor}${c.bold}[${report.bump}]${c.reset}\n`,
+      `${c.bold}📦 ${report.name.padEnd(12)}${c.reset} ${highlightVersion(report.currentVersion, report.newVersion)} ${bumpColor}${c.bold}[${report.bump}]${c.reset}${firstReleaseBadge}\n`,
     );
 
     const files = report.updates.map(
@@ -80,8 +85,9 @@ export function prettyPrint(reports: DependencyUpdateReport[]): void {
 
       const marker = affectsBump ? `${c.green}✦${c.reset}` : `${c.gray}○${c.reset}`;
 
+      // User string is now wrapped with <>
       console.log(
-        `     ${marker} ${c.yellow}${commit.shortHash}${c.reset} ${commit.message}  ${c.gray}${commit.author} ${commit.date}${c.reset}`,
+        `     ${marker} ${c.yellow}${commit.shortHash}${c.reset} ${commit.message}  ${c.gray}<${commit.author}> ${commit.date}${c.reset}`,
       );
     }
 
@@ -103,7 +109,6 @@ export function prettyPrint(reports: DependencyUpdateReport[]): void {
       );
     }
 
-    // Changelog Preview
     console.log('');
   }
 }

package/src/run.ts

@@ -4,73 +4,26 @@ import path from 'node:path';
 import type { DependencyUpdateReport, VcsProvider } from './types';
 
 /**
- * Applies calculated updates to files on disk, stages, commits, and tags using the provided VcsProvider.
+ * Builds the multi-line commit message showcasing version bumps, included commits,
+ * cascade triggers, and first-release indicators.
  */
-export async function run(
-  reports: DependencyUpdateReport[],
-  vcs: VcsProvider,
-  options: { cwd: string },
-): Promise<void> {
-  const cwd = options.cwd;
-
-  // 1. Apply file updates
-  for (const report of reports) {
-    for (const u of report.updates) {
-      const filePath = path.resolve(cwd, u.path);
-      const dirPath = path.dirname(filePath);
-      if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-      }
-
-      if (u.kind === 'toml') {
-        if (fs.existsSync(filePath)) {
-          let content = fs.readFileSync(filePath, 'utf8');
-          // Update package version inside the target Cargo.toml package block
-          content = content.replace(
-            /(\[package\][^]*?^version\s*=\s*")[^"]+(")/m,
-            `$1${report.newVersion}$2`,
-          );
-          // Sync workspace dependency entries if internal dependencies changed
-          for (const depReport of reports) {
-            if (depReport.name === report.name) continue;
-            const depRegex = new RegExp(
-              `(${depReport.name}\\s*=\\s*\\{[^}]*version\\s*=\\s*")[^"]+(")`,
-              'g',
-            );
-            content = content.replace(depRegex, `$1${depReport.newVersion}$2`);
-          }
-          fs.writeFileSync(filePath, content);
-        }
-      } else if (u.kind === 'regex') {
-        if (fs.existsSync(filePath)) {
-          let content = fs.readFileSync(filePath, 'utf8');
-          const searchRegex = new RegExp(u.search, 'g');
-          content = content.replace(searchRegex, u.resolvedReplace ?? '');
-          fs.writeFileSync(filePath, content);
-        }
-      } else if (u.kind === 'changelog') {
-        const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
-        const newContent = (u.resolvedBlock ?? '') + '\n' + oldContent;
-        fs.writeFileSync(filePath, newContent.trim() + '\n');
-      }
-    }
-  }
-
-  // 2. Build multi-line commit message
+export function generateCommitMessage(reports: DependencyUpdateReport[]): string | null {
   const activeReports = reports.filter((r) => r.bump !== 'skip');
   if (activeReports.length === 0) {
-    return;
+    return null;
   }
 
   const tagList = activeReports.map((r) => `${r.name}-v${r.newVersion}`).join(', ');
   let commitMessage = `chore: release ${tagList}\n\n`;
 
   for (const report of activeReports) {
-    commitMessage += `${report.name} (${report.currentVersion} -> ${report.newVersion}) [${report.bump}]\n`;
+    const firstReleaseBadge = report.isFirstRelease ? ' (first release)' : '';
+
+    commitMessage += `${report.name} (${report.currentVersion} -> ${report.newVersion}) [${report.bump}]${firstReleaseBadge}\n`;
 
     // Add commits
     for (const commit of report.commits) {
-      commitMessage += `  - ${commit.shortHash} ${commit.message} (${commit.author} ${commit.date})\n`;
+      commitMessage += `  - ${commit.shortHash} ${commit.message} (<${commit.author}> ${commit.date})\n`;
     }
 
     // Add cascades
@@ -86,10 +39,51 @@ export async function run(
     commitMessage += '\n';
   }
 
+  return commitMessage.trim();
+}
+
+/**
+ * Applies calculated updates to files on disk, stages, commits, and tags using the provided VcsProvider.
+ */
+export async function run(
+  reports: DependencyUpdateReport[],
+  vcs: VcsProvider,
+  options: { cwd: string },
+): Promise<void> {
+  const erroneous = reports.filter((r) => r.isErroneous);
+  if (erroneous.length > 0) {
+    const names = erroneous.map((r) => r.name).join(', ');
+    throw new Error(
+      `Cannot run because the following packages are missing versions or required updates: ${names}`,
+    );
+  }
+
+  const cwd = options.cwd;
+
+  // 1. Apply file updates
+  for (const report of reports) {
+    for (const u of report.updates) {
+      const filePath = path.resolve(cwd, u.path);
+      const dirPath = path.dirname(filePath);
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+      }
+
+      u.apply(report, reports, cwd);
+    }
+  }
+
+  // 2. Build multi-line commit message
+  const commitMessage = generateCommitMessage(reports);
+  if (!commitMessage) {
+    return;
+  }
+
   // 3. Stage and execute commit
-  await vcs.commit(commitMessage.trim());
+  await vcs.commit(commitMessage);
 
   // 4. Create tags
+  const activeReports = reports.filter((r) => r.bump !== 'skip');
   for (const report of activeReports) {
     const tagName = `${report.name}-v${report.newVersion}`;
     await vcs.tag(tagName);