relacher 0.0.2 → 0.0.4-rc.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 Emilien Jegou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -6,12 +6,7 @@
 
 **Relacher** is a scriptable, workspace-aware release orchestration library designed for monorepos.
 
-```
-📦 cli_tool     3.1.2 → 3.3.0 [minor]
-   flake.nix  README.md  CHANGELOG.md  CHANGELOG.md
-     ✦ 4a0ce62 feat(ui): add progress indicator to execution flow  Author 2025-01-30
-     ✦ Cascaded as [minor] from deps: plugin_api [minor]
-```
+![Relacher](./docs/assets/relacher.png)
 
 ## Features
 

package/lib-types/index.d.ts

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

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

@@ -0,0 +1,56 @@
+import type { Commit, DependencyUpdateReport } from '../types';
+export type UpdateActionOptions = {
+    newVersion: string;
+    globalCommits: Commit[];
+    crateCommits: Commit[];
+};
+export interface UpdateActionResolved {
+    kind: string;
+    targetPath: string;
+    apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string): void;
+    params: any;
+    preparedData: any;
+}
+export interface UpdateAction {
+    kind: string;
+    path: string;
+    required?: boolean;
+    params: any;
+    prepare(data: UpdateActionOptions): UpdateActionResolved;
+}
+export interface VersionFallback {
+    readFallback(cwd: string): string | null;
+}
+export type ApplyActionFnArgs<T, K = undefined> = {
+    params: T;
+    targetPath: string;
+    options: UpdateActionOptions;
+    report: DependencyUpdateReport;
+    reports: DependencyUpdateReport[];
+    cwd: string;
+    preparedData: K;
+};
+type ApplyActionFn<T, K = undefined> = (args: ApplyActionFnArgs<T, K>) => void;
+export type PrepareActionFnArgs<T> = {
+    params: T;
+    targetPath: string;
+    options: UpdateActionOptions;
+};
+type PrepareActionFn<T, K> = (args: PrepareActionFnArgs<T>) => K;
+type UpdateBuilderParams<T, K = undefined> = {
+    kind: string;
+    apply: ApplyActionFn<T, K>;
+    prepare?: PrepareActionFn<T, K>;
+};
+export declare const updateBuilder: <T, K = undefined>({ kind, apply, prepare }: UpdateBuilderParams<T, K>) => (targetPath: string, params: T & {
+    required?: boolean;
+}) => {
+    kind: string;
+    path: string;
+    params: T & {
+        required?: boolean;
+    };
+    required: boolean | undefined;
+    prepare(options: UpdateActionOptions): UpdateActionResolved;
+};
+export {};

package/lib-types/updater/changelog.d.ts

@@ -1,10 +1,18 @@
-import type { ChangelogContext } from '../types';
-import type { UpdateAction } from '.';
+import { type ChangelogContext } from '../types';
 export type ChangelogUpdateParams = {
-    path: string;
     global?: boolean;
     template?: (ctx: ChangelogContext) => string;
     required?: boolean;
 };
-export declare const changelogUpdate: (params: ChangelogUpdateParams) => UpdateAction;
+export declare const changelogUpdate: (targetPath: string, params: ChangelogUpdateParams & {
+    required?: boolean;
+}) => {
+    kind: string;
+    path: string;
+    params: ChangelogUpdateParams & {
+        required?: boolean;
+    };
+    required: boolean | undefined;
+    prepare(options: import("./builder").UpdateActionOptions): import("./builder").UpdateActionResolved;
+};
 export declare function defaultChangelogTemplate({ version, date, commits }: ChangelogContext): string;

package/lib-types/updater/index.d.ts

@@ -1,26 +1,5 @@
-import type { Commit, DependencyUpdateReport } from '../types';
+export * from './builder';
 export * from './changelog';
 export * from './json';
 export * from './regex';
 export * from './toml';
-export type UpdateActionOptions = {
-    newVersion: string;
-    globalCommits: Commit[];
-    crateCommits: Commit[];
-};
-export interface UpdateActionResolved {
-    kind: string;
-    path: string;
-    apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string): void;
-    params: any;
-}
-export interface UpdateAction {
-    kind: string;
-    path: string;
-    required?: boolean;
-    params: any;
-    prepare(data: UpdateActionOptions): UpdateActionResolved;
-}
-export interface VersionFallback {
-    readFallback(cwd: string): string | null;
-}

package/lib-types/updater/json.d.ts

@@ -1,12 +1,19 @@
-import type { VersionFallback, UpdateAction } from '.';
+import type { DependencyUpdateReport } from '../types';
+import { type VersionFallback } from '.';
 export type JsonFallbackParams = {
     path: string;
-    json: string;
+    read: (parsed: any) => string | null | undefined;
 };
-export type JsonUpdateParams = {
-    path: string;
-    json: string;
+export type JsonUpdateParams = (parsed: any, report: DependencyUpdateReport, reports: DependencyUpdateReport[]) => void;
+export declare const jsonFallback: (params: JsonFallbackParams) => VersionFallback;
+export declare const jsonUpdate: (targetPath: string, params: JsonUpdateParams & {
     required?: boolean;
+}) => {
+    kind: string;
+    path: string;
+    params: JsonUpdateParams & {
+        required?: boolean;
+    };
+    required: boolean | undefined;
+    prepare(options: import("./builder").UpdateActionOptions): import("./builder").UpdateActionResolved;
 };
-export declare const jsonFallback: (params: JsonFallbackParams) => VersionFallback;
-export declare const jsonUpdate: (params: JsonUpdateParams) => UpdateAction;

package/lib-types/updater/regex.d.ts

@@ -1,13 +1,22 @@
-import type { VersionFallback, UpdateAction } from '.';
+import { type VersionFallback } from '.';
 export type RegexFallbackParams = {
     path: string;
     search: string;
 };
 export type RegexUpdateParams = {
-    path: string;
     search: string;
     replace: string;
     required?: boolean;
 };
 export declare const regexFallback: (params: RegexFallbackParams) => VersionFallback;
-export declare const regexUpdate: (params: RegexUpdateParams) => UpdateAction;
+export declare const regexUpdate: (targetPath: string, params: RegexUpdateParams & {
+    required?: boolean;
+}) => {
+    kind: string;
+    path: string;
+    params: RegexUpdateParams & {
+        required?: boolean;
+    };
+    required: boolean | undefined;
+    prepare(options: import("./builder").UpdateActionOptions): import("./builder").UpdateActionResolved;
+};

package/lib-types/updater/toml.d.ts

@@ -1,12 +1,19 @@
-import type { VersionFallback, UpdateAction } from '.';
+import type { DependencyUpdateReport } from '../types';
+import { type VersionFallback } from '.';
 export type TomlFallbackParams = {
     path: string;
-    toml: string;
+    read: (parsed: any) => string | null | undefined;
 };
-export type TomlUpdateParams = {
-    path: string;
-    toml: string;
+export type TomlUpdateParams = (parsed: any, report: DependencyUpdateReport, reports: DependencyUpdateReport[]) => void;
+export declare const tomlFallback: (params: TomlFallbackParams) => VersionFallback;
+export declare const tomlUpdate: (targetPath: string, params: TomlUpdateParams & {
     required?: boolean;
+}) => {
+    kind: string;
+    path: string;
+    params: TomlUpdateParams & {
+        required?: boolean;
+    };
+    required: boolean | undefined;
+    prepare(options: import("./builder").UpdateActionOptions): import("./builder").UpdateActionResolved;
 };
-export declare const tomlFallback: (params: TomlFallbackParams) => VersionFallback;
-export declare const tomlUpdate: (params: TomlUpdateParams) => UpdateAction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relacher",
-  "version": "0.0.2",
+  "version": "0.0.4-rc.0",
   "description": "Scriptable release orchestration library for monorepos",
   "type": "module",
   "private": false,
@@ -56,6 +56,7 @@
     "oxfmt": "^0.19.0",
     "oxlint": "^1.64.0",
     "prettier": "^3.8.3",
+    "smol-toml": "^1.6.1",
     "typescript": "^6.0.3"
   }
 }

package/src/builder/cargo.ts

@@ -1,8 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { parse } from 'smol-toml';
+
 import type { DependencyConfig } from '../types';
-import { regexUpdate, tomlUpdate, tomlFallback } from '../updater';
+import { tomlUpdate, tomlFallback } from '../updater';
 
 import { decorateList, type DependencyList } from './shared';
 
@@ -16,19 +18,49 @@ export interface CargoBuilderOptions {
 export function cargoProject(cwd: string): DependencyList {
   const configs: DependencyConfig[] = [];
   const rootCargo = path.join(cwd, 'Cargo.toml');
+  const lockCargo = path.join(cwd, 'Cargo.lock');
+  const hasLock = fs.existsSync(lockCargo);
 
   if (fs.existsSync(rootCargo)) {
-    const fileContent = fs.readFileSync(rootCargo, 'utf8');
-    const nameMatch = fileContent.match(/^name\s*=\s*"([^"]+)"/m);
-    const parsedName = nameMatch?.[1] ?? '';
-    if (parsedName) {
-      configs.push({
-        name: parsedName,
-        watch: ['.'],
-        depends: [],
-        versionFallback: tomlFallback({ path: 'Cargo.toml', toml: 'package.version' }),
-        updates: [tomlUpdate({ path: 'Cargo.toml', toml: 'package.version' })],
-      });
+    try {
+      const fileContent = fs.readFileSync(rootCargo, 'utf8');
+      const doc = parse(fileContent) as any;
+      const parsedName = doc.package?.name;
+
+      if (parsedName) {
+        const updates = [
+          tomlUpdate('Cargo.toml', (d, r) => {
+            if (d.package) d.package.version = r.newVersion;
+          }),
+        ];
+
+        if (hasLock) {
+          updates.push(
+            tomlUpdate('Cargo.lock', (d, r) => {
+              if (Array.isArray(d.package)) {
+                // Only update local packages (missing source/checksum attributes)
+                const pkg = d.package.find(
+                  (p: any) => p.name === parsedName && !p.source && !p.checksum,
+                );
+                if (pkg) pkg.version = r.newVersion;
+              }
+            }),
+          );
+        }
+
+        configs.push({
+          name: parsedName,
+          watch: ['.'],
+          depends: [],
+          versionFallback: tomlFallback({
+            path: 'Cargo.toml',
+            read: (d) => d.package?.version,
+          }),
+          updates,
+        });
+      }
+    } catch {
+      // Ignore parse error
     }
   }
 
@@ -41,118 +73,162 @@ export function cargoProject(cwd: string): DependencyList {
 export function cargoWorkspace(cwd: string, options?: CargoBuilderOptions): DependencyList {
   const configs: DependencyConfig[] = [];
   const rootCargo = path.join(cwd, 'Cargo.toml');
+  const lockCargo = path.join(cwd, 'Cargo.lock');
+  const hasLock = fs.existsSync(lockCargo);
   const discoveredPaths = new Set<string>();
 
   if (fs.existsSync(rootCargo)) {
-    const content = fs.readFileSync(rootCargo, 'utf8');
-    const membersMatch = content.match(/members\s*=\s*\[([^\]]+)\]/);
-    if (membersMatch && membersMatch[1]) {
-      const rawMembers = membersMatch[1].split(',').map((m) => m.replace(/["\s]/g, ''));
-      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.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?.[1] ?? '';
-            if (parsedName) {
-              crateInfos.push({
-                name: parsedName,
-                memberPath,
-                content: fileContent,
-              });
+    try {
+      const content = fs.readFileSync(rootCargo, 'utf8');
+      const rootDoc = parse(content) as any;
+      const members = rootDoc.workspace?.members;
+
+      if (Array.isArray(members)) {
+        const crateInfos: { name: string; memberPath: string; doc: any }[] = [];
+
+        for (const member of members) {
+          const globPath = path.join(cwd, member);
+          const cargoPaths = globPath.endsWith('*')
+            ? 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 doc = parse(fileContent) as any;
+              const parsedName = doc.package?.name;
+              if (parsedName) {
+                crateInfos.push({ name: parsedName, memberPath, doc });
+              }
             }
           }
         }
-      }
 
-      // 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;
+        // Discover nested packages dynamically via path dependencies on the parsed objects
+        let i = 0;
+        while (i < crateInfos.length) {
+          const info = crateInfos[i]!;
+          const deps = [
+            ...(Object.values(info.doc.dependencies || {}) as any[]),
+            ...(Object.values(info.doc['dev-dependencies'] || {}) as any[]),
+            ...(Object.values(info.doc['build-dependencies'] || {}) as any[]),
+          ];
+
+          for (const dep of deps) {
+            if (dep && typeof dep === 'object' && dep.path) {
+              const fullDepPath = path.resolve(info.memberPath, dep.path);
+              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 doc = parse(fileContent) as any;
+                  const parsedName = doc.package?.name;
+                  if (parsedName) {
+                    crateInfos.push({ name: parsedName, memberPath: fullDepPath, doc });
+                  }
+                }
+              }
+            }
           }
+          i++;
+        }
 
-          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,
-              });
+        for (const info of crateInfos) {
+          const relativePath = path.relative(cwd, info.memberPath);
+          const posixRelativePath = relativePath.split(path.sep).join(path.posix.sep);
+          const relativeCargo = posixRelativePath
+            ? path.posix.join(posixRelativePath, 'Cargo.toml')
+            : 'Cargo.toml';
+
+          const depends: string[] = [];
+          const allDeps = {
+            ...(info.doc.dependencies || {}),
+            ...(info.doc['dev-dependencies'] || {}),
+            ...(info.doc['build-dependencies'] || {}),
+          };
+
+          for (const other of crateInfos) {
+            if (other.name === info.name) continue;
+            if (allDeps[other.name]) {
+              depends.push(other.name);
             }
           }
-        }
-        i++;
-      }
 
-      for (const info of crateInfos) {
-        const relativePath = path.relative(cwd, info.memberPath);
-        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(`^\\s*${other.name}\\s*=`, 'm');
-          if (depPattern.test(info.content)) {
-            depends.push(other.name);
+          const updates = [
+            tomlUpdate(relativeCargo, (doc, report, reports) => {
+              // Update self
+              if (doc.package) {
+                doc.package.version = report.newVersion;
+              }
+
+              // Keep local path workspace dependencies perfectly in sync internally
+              const depTypes = ['dependencies', 'dev-dependencies', 'build-dependencies'];
+              for (const depType of depTypes) {
+                if (!doc[depType]) continue;
+                for (const depReport of reports) {
+                  if (depReport.name === report.name) continue;
+                  const dep = doc[depType][depReport.name];
+                  if (dep && typeof dep === 'object' && dep.version) {
+                    dep.version = depReport.newVersion;
+                  } else if (typeof dep === 'string') {
+                    doc[depType][depReport.name] = depReport.newVersion;
+                  }
+                }
+              }
+            }),
+          ];
+
+          if (hasLock) {
+            updates.push(
+              tomlUpdate('Cargo.lock', (doc, report) => {
+                if (Array.isArray(doc.package)) {
+                  // Only update local packages (missing source/checksum attributes)
+                  const pkg = doc.package.find(
+                    (p: any) => p.name === info.name && !p.source && !p.checksum,
+                  );
+                  if (pkg) pkg.version = report.newVersion;
+                }
+              }),
+            );
           }
-        }
 
-        const updates = [tomlUpdate({ path: relativeCargo, toml: 'package.version' })];
+          if (options?.syncWorkspaceDeps) {
+            updates.push(
+              tomlUpdate('Cargo.toml', (doc, report) => {
+                if (doc.workspace?.dependencies?.[info.name]) {
+                  const dep = doc.workspace.dependencies[info.name];
+                  if (typeof dep === 'object' && dep.version) {
+                    dep.version = report.newVersion;
+                  } else if (typeof dep === 'string') {
+                    doc.workspace.dependencies[info.name] = report.newVersion;
+                  }
+                }
+              }),
+            );
+          }
 
-        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: [posixRelativePath || '.'],
+            depends,
+            versionFallback: tomlFallback({
+              path: relativeCargo,
+              read: (doc) => doc.package?.version,
             }),
-          );
+            updates,
+          });
         }
-
-        configs.push({
-          name: info.name,
-          watch: [posixRelativePath || '.'],
-          depends,
-          versionFallback: tomlFallback({ path: relativeCargo, toml: 'package.version' }),
-          updates,
-        });
       }
+    } catch {
+      // Ignore parse error
     }
   }
 
@@ -162,12 +238,17 @@ export function cargoWorkspace(cwd: string, options?: CargoBuilderOptions): Depe
 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, options);
-    }
-    if (content.includes('package =') || content.match(/^name\s*=/m)) {
-      return cargoProject(cwd);
+    try {
+      const content = fs.readFileSync(rootCargo, 'utf8');
+      const doc = parse(content) as any;
+      if (doc.workspace?.members) {
+        return cargoWorkspace(cwd, options);
+      }
+      if (doc.package?.name) {
+        return cargoProject(cwd);
+      }
+    } catch {
+      // Fallback below
     }
   }
   return decorateList([]);

package/src/builder/pnpm.ts

@@ -22,11 +22,13 @@ export function pnpmProject(cwd: string): DependencyList {
           name: parsed.name,
           watch: ['.'],
           depends: [],
-          versionFallback: jsonFallback({ path: 'package.json', json: 'version' }),
+          versionFallback: jsonFallback({
+            path: 'package.json',
+            read: (parsed) => parsed.version,
+          }),
           updates: [
-            jsonUpdate({
-              path: 'package.json',
-              json: 'version',
+            jsonUpdate('package.json', (parsed, report) => {
+              parsed.version = report.newVersion;
             }),
           ],
         });
@@ -139,11 +141,38 @@ export function pnpmWorkspace(cwd: string): DependencyList {
       name: info.name,
       watch: [posixRelativePath || '.'],
       depends,
-      versionFallback: jsonFallback({ path: relativePJson, json: 'version' }),
+      versionFallback: jsonFallback({
+        path: relativePJson,
+        read: (parsed) => parsed.version,
+      }),
       updates: [
-        jsonUpdate({
-          path: relativePJson,
-          json: 'version',
+        jsonUpdate(relativePJson, (parsed, report, reports) => {
+          // Update local package version
+          parsed.version = report.newVersion;
+
+          // Sync internal workspace dependencies and preserve prefixing if present
+          const depSections = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+          ] as const;
+
+          for (const depReport of reports) {
+            if (depReport.name === report.name) continue;
+
+            for (const section of depSections) {
+              if (parsed[section] && parsed[section][depReport.name]) {
+                const currentVal = parsed[section][depReport.name];
+                if (typeof currentVal === 'string') {
+                  // Match prefix structures such as '^', '~', 'workspace:^', or 'workspace:'
+                  const match = currentVal.match(/^((?:workspace:)?([~^]?))/);
+                  const prefix = match ? match[1] : '';
+                  parsed[section][depReport.name] = `${prefix}${depReport.newVersion}`;
+                }
+              }
+            }
+          }
         }),
       ],
     });

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/print.ts

@@ -74,7 +74,7 @@ export function prettyPrint(reports: DependencyUpdateReport[]): void {
 
     const files = report.updates.map(
       (u) =>
-        `${getIconForFile(u.path.split('/').pop() || '')} ${c.dim}${u.path.split('/').pop()}${c.reset}`,
+        `${getIconForFile(u.targetPath.split('/').pop() || '')} ${c.dim}${u.targetPath.split('/').pop()}${c.reset}`,
     );
     console.log(`   ${files.join('  ')}`);
 

package/src/run.ts

@@ -63,7 +63,7 @@ export async function run(
   // 1. Apply file updates
   for (const report of reports) {
     for (const u of report.updates) {
-      const filePath = path.resolve(cwd, u.path);
+      const filePath = path.resolve(cwd, u.targetPath);
       const dirPath = path.dirname(filePath);
       if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });

package/src/updater/builder.ts

@@ -0,0 +1,83 @@
+import type { Commit, DependencyUpdateReport } from '../types';
+
+export type UpdateActionOptions = {
+  newVersion: string;
+  globalCommits: Commit[];
+  crateCommits: Commit[];
+};
+
+export interface UpdateActionResolved {
+  kind: string;
+  targetPath: string;
+  apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string): void;
+  params: any;
+  preparedData: any;
+}
+
+export interface UpdateAction {
+  kind: string;
+  path: string;
+  required?: boolean;
+  params: any;
+  prepare(data: UpdateActionOptions): UpdateActionResolved;
+}
+
+export interface VersionFallback {
+  readFallback(cwd: string): string | null;
+}
+
+export type ApplyActionFnArgs<T, K = undefined> = {
+  params: T;
+  targetPath: string;
+  options: UpdateActionOptions;
+  report: DependencyUpdateReport;
+  reports: DependencyUpdateReport[];
+  cwd: string;
+  preparedData: K; // Added preparedData to the arguments
+};
+
+type ApplyActionFn<T, K = undefined> = (args: ApplyActionFnArgs<T, K>) => void;
+
+export type PrepareActionFnArgs<T> = {
+  params: T;
+  targetPath: string;
+  options: UpdateActionOptions;
+};
+
+type PrepareActionFn<T, K> = (args: PrepareActionFnArgs<T>) => K;
+
+type UpdateBuilderParams<T, K = undefined> = {
+  kind: string;
+  apply: ApplyActionFn<T, K>; // Passed K here
+  prepare?: PrepareActionFn<T, K>;
+};
+
+export const updateBuilder =
+  <T, K = undefined>({ kind, apply, prepare }: UpdateBuilderParams<T, K>) =>
+    (targetPath: string, params: T & { required?: boolean }) => ({
+      kind,
+      path: targetPath,
+      params,
+      required: params.required,
+      prepare(options: UpdateActionOptions): UpdateActionResolved {
+        const preparedData = prepare?.({ params, targetPath, options }) as K;
+
+        return {
+          kind,
+          targetPath,
+          params,
+          preparedData,
+          apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string) {
+            apply({
+              preparedData,
+              targetPath,
+              params,
+              options,
+              report,
+              reports,
+              cwd,
+            });
+          },
+        };
+      },
+    });

package/src/updater/changelog.ts

@@ -1,50 +1,46 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import type { ChangelogContext } from '../types';
+import { type ChangelogContext, type Commit } from '../types'; // Assuming these types are defined here
 
-import type { UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+import { updateBuilder, type PrepareActionFnArgs, type ApplyActionFnArgs } from './builder';
 
 export type ChangelogUpdateParams = {
-  path: string;
   global?: boolean;
   template?: (ctx: ChangelogContext) => string;
   required?: boolean;
 };
 
-export const changelogUpdate = (params: ChangelogUpdateParams): UpdateAction => ({
+// Define the type for data prepared by the 'prepare' function
+type ChangelogPreparedData = {
+  resolvedBlock: string;
+};
+
+export const changelogUpdate = updateBuilder<ChangelogUpdateParams, ChangelogPreparedData>({
   kind: 'changelog',
-  path: params.path,
-  required: params.required,
-  params,
-  prepare(data: UpdateActionOptions): UpdateActionResolved {
-    const targetCommits = params.global ? data.globalCommits : data.crateCommits;
+  prepare: ({ params, options }: PrepareActionFnArgs<ChangelogUpdateParams>) => {
+    const targetCommits = params.global ? options.globalCommits : options.crateCommits;
     const context: ChangelogContext = {
-      version: data.newVersion,
+      version: options.newVersion,
       date: new Date().toISOString().split('T')[0] ?? '',
-      commits: targetCommits,
+      commits: targetCommits || [],
     };
 
     const resolvedBlock = params.template
       ? params.template(context)
       : defaultChangelogTemplate(context);
 
-    const t = {
-      kind: 'changelog',
-      path: params.path,
-      params: {
-        ...params,
-        resolvedBlock,
-      },
-      apply(_report, _reports, cwd) {
-        const filePath = path.resolve(cwd, params.path);
-        const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
-        const newContent = (resolvedBlock ?? '') + '\n' + oldContent;
-        fs.writeFileSync(filePath, newContent.trim() + '\n');
-      },
-    } satisfies UpdateActionResolved;
-
-    return t;
+    return { resolvedBlock };
+  },
+  apply: ({
+    targetPath,
+    preparedData,
+    cwd,
+  }: ApplyActionFnArgs<ChangelogUpdateParams, ChangelogPreparedData>) => {
+    const filePath = path.resolve(cwd, targetPath);
+    const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+    const newContent = (preparedData.resolvedBlock ?? '') + '\n' + oldContent;
+    fs.writeFileSync(filePath, newContent.trim() + '\n');
   },
 });
 
@@ -52,7 +48,7 @@ export function defaultChangelogTemplate({ version, date, commits }: ChangelogCo
   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[] } = {
+  const groups: { breaking: Commit[]; feat: Commit[]; fix: Commit[]; other: Commit[] } = {
     breaking: [],
     feat: [],
     fix: [],
@@ -60,17 +56,19 @@ export function defaultChangelogTemplate({ version, date, commits }: ChangelogCo
   };
 
   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 (c.isBreaking) groups.breaking.push(c);
+    else if (c.type === 'feat') groups.feat.push(c);
+    else if (c.type === 'fix') groups.fix.push(c);
+    else groups.other.push(c);
   }
 
-  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`;
+  const formatGroup = (arr: Commit[]) => arr.map((c) => `- ${c.shortHash} ${c.message}`).join('\n');
+
+  if (groups.breaking.length)
+    block += `### ⚠️ BREAKING CHANGES\n${formatGroup(groups.breaking)}\n\n`;
+  if (groups.feat.length) block += `### ✨ Features\n${formatGroup(groups.feat)}\n\n`;
+  if (groups.fix.length) block += `### 🐛 Bug Fixes\n${formatGroup(groups.fix)}\n\n`;
+  if (groups.other.length) block += `### 🛠 Other Changes\n${formatGroup(groups.other)}\n\n`;
 
   return block.trim() + '\n';
 }

package/src/updater/index.ts

@@ -1,31 +1,6 @@
-import type { Commit, DependencyUpdateReport } from '../types';
-
+export * from './builder';
 export * from './changelog';
 export * from './json';
 export * from './regex';
 export * from './toml';
 
-export type UpdateActionOptions = {
-  newVersion: string;
-  globalCommits: Commit[];
-  crateCommits: Commit[];
-};
-
-export interface UpdateActionResolved {
-  kind: string;
-  path: string;
-  apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string): void;
-  params: any;
-}
-
-export interface UpdateAction {
-  kind: string;
-  path: string;
-  required?: boolean;
-  params: any;
-  prepare(data: UpdateActionOptions): UpdateActionResolved;
-}
-
-export interface VersionFallback {
-  readFallback(cwd: string): string | null;
-}

package/src/updater/json.ts

@@ -1,95 +1,61 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import type { VersionFallback, UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+import type { DependencyUpdateReport } from '../types';
 
-export type JsonFallbackParams = { path: string; json: string };
-export type JsonUpdateParams = { path: string; json: string; required?: boolean };
+import { type VersionFallback, updateBuilder } from '.';
+
+export type JsonFallbackParams = {
+  path: string;
+  read: (parsed: any) => string | null | undefined;
+};
+
+export type JsonUpdateParams = (
+  parsed: any,
+  report: DependencyUpdateReport,
+  reports: DependencyUpdateReport[],
+) => void;
 
 export const jsonFallback = (params: JsonFallbackParams): VersionFallback => ({
   readFallback(cwd: string): string | null {
     const filePath = path.resolve(cwd, params.path);
     if (!fs.existsSync(filePath)) return null;
     try {
-      const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-      const keys = params.json.split('.');
-      let val: any = data;
-      for (const k of keys) {
-        if (val == null) return null;
-        val = val[k];
-      }
-      return typeof val === 'string' ? val : null;
+      const content = fs.readFileSync(filePath, 'utf8');
+      const parsed = JSON.parse(content);
+      return params.read(parsed) ?? null;
     } catch {
       return null;
     }
   },
 });
 
-export const jsonUpdate = (params: JsonUpdateParams): UpdateAction => ({
+export const jsonUpdate = updateBuilder<JsonUpdateParams>({
   kind: 'json',
-  path: params.path,
-  required: params.required,
-  params,
-  prepare(_data: UpdateActionOptions): UpdateActionResolved {
-    return {
-      kind: 'json',
-      path: params.path,
-      params,
-      apply(report, reports, cwd) {
-        const filePath = path.resolve(cwd, params.path);
-        if (!fs.existsSync(filePath)) return;
-
-        const content = fs.readFileSync(filePath, 'utf8');
-
-        // Detect indent size
-        const indentMatch = content.match(/^[ \t]+/m);
-        const indent = indentMatch ? indentMatch[0] : 2;
+  apply({ targetPath, params, report, reports, cwd }) {
+    const filePath = path.resolve(cwd, targetPath);
+    if (!fs.existsSync(filePath)) return;
 
-        let data: Record<string, any>;
-        try {
-          data = JSON.parse(content);
-        } catch (err) {
-          console.error(`Failed to parse JSON file at ${filePath}`);
-          return;
-        }
-
-        // Update specific JSON path
-        const keys = params.json.split('.');
-        const lastKey = keys.pop();
-        if (lastKey) {
-          let target = data;
-          for (const k of keys) {
-            if (target[k] == null || typeof target[k] !== 'object') {
-              target[k] = {};
-            }
-            target = target[k];
-          }
-          target[lastKey] = report.newVersion;
-        }
+    const content = fs.readFileSync(filePath, 'utf8');
+    let parsed: any;
+    try {
+      parsed = JSON.parse(content);
+    } catch (err) {
+      console.error(`Failed to parse JSON file at ${filePath}:`, err);
+      return;
+    }
 
-        // Sync internal workspace dependency entries
-        const depSections = [
-          'dependencies',
-          'devDependencies',
-          'peerDependencies',
-          'optionalDependencies',
-        ];
+    // Detect indent size
+    const indentMatch = content.match(/^[ \t]+/m);
+    const indent = indentMatch ? indentMatch[0] : 2;
 
-        for (const depReport of reports) {
-          if (depReport.name === report.name) continue;
+    // Mutate the object using the provided callback
+    params(parsed, report, reports);
 
-          for (const section of depSections) {
-            if (data[section] && data[section][depReport.name]) {
-              const currentVal = data[section][depReport.name] as string;
-              const prefixMatch = currentVal.match(/^([~^]?)(.*)$/);
-              const prefix = prefixMatch ? prefixMatch[1] : '';
-              data[section][depReport.name] = `${prefix}${depReport.newVersion}`;
-            }
-          }
-        }
+    // Keep trailing newline if it originally existed
+    const hasTrailingNewline = content.endsWith('\n');
+    const updatedContent = JSON.stringify(parsed, null, indent) + (hasTrailingNewline ? '\n' : '');
 
-        fs.writeFileSync(filePath, JSON.stringify(data, null, indent) + '\n');
-      },
-    };
+    fs.writeFileSync(filePath, updatedContent);
   },
 });

package/src/updater/regex.ts

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import type { VersionFallback, UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+import { updateBuilder, type PrepareActionFnArgs, type ApplyActionFnArgs } from './builder';
+
+import { type VersionFallback } from '.';
 
 export type RegexFallbackParams = { path: string; search: string };
 export type RegexUpdateParams = {
-  path: string;
   search: string;
   replace: string;
   required?: boolean;
@@ -22,27 +23,35 @@ export const regexFallback = (params: RegexFallbackParams): VersionFallback => (
   },
 });
 
-export const regexUpdate = (params: RegexUpdateParams): UpdateAction => ({
+// Define the type for data prepared by the 'prepare' function
+type RegexPreparedData = {
+  resolvedReplace: string;
+};
+
+export const regexUpdate = updateBuilder<RegexUpdateParams, RegexPreparedData>({
   kind: 'regex',
-  path: params.path,
-  required: params.required,
-  params,
-  prepare(data: UpdateActionOptions): UpdateActionResolved {
-    const resolvedReplace = params.replace.replace('{{version}}', data.newVersion);
-
-    return {
-      kind: 'regex',
-      path: params.path,
-      params: { ...params, resolvedReplace },
-      apply(_report, _reports, cwd) {
-        const filePath = path.resolve(cwd, params.path);
-        if (!fs.existsSync(filePath)) return;
-
-        let content = fs.readFileSync(filePath, 'utf8');
-        const searchRegex = new RegExp(params.search, 'g');
-        content = content.replace(searchRegex, resolvedReplace);
-        fs.writeFileSync(filePath, content);
-      },
-    };
+
+  prepare: ({ params, options }: PrepareActionFnArgs<RegexUpdateParams>) => {
+    // Pre-calculate the replacement string with the new version
+    const resolvedReplace = params.replace.replace('{{version}}', options.newVersion);
+    return { resolvedReplace };
+  },
+
+  apply: ({
+    targetPath,
+    params,
+    preparedData,
+    cwd,
+  }: ApplyActionFnArgs<RegexUpdateParams, RegexPreparedData>) => {
+    const filePath = path.resolve(cwd, targetPath);
+    if (!fs.existsSync(filePath)) {
+      console.warn(`File not found for regex update (path: ${filePath}). Skipping.`);
+      return;
+    }
+
+    let content = fs.readFileSync(filePath, 'utf8');
+    const searchRegex = new RegExp(params.search, 'g');
+    content = content.replace(searchRegex, preparedData.resolvedReplace);
+    fs.writeFileSync(filePath, content);
   },
 });

package/src/updater/toml.ts

@@ -1,57 +1,49 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import type { VersionFallback, UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+import { parse, stringify } from 'smol-toml';
 
-export type TomlFallbackParams = { path: string; toml: string };
-export type TomlUpdateParams = { path: string; toml: string; required?: boolean };
+import type { DependencyUpdateReport } from '../types';
+
+import { type VersionFallback, updateBuilder } from '.';
+
+export type TomlFallbackParams = {
+  path: string;
+  read: (parsed: any) => string | null | undefined;
+};
+
+export type TomlUpdateParams = (
+  parsed: any,
+  report: DependencyUpdateReport,
+  reports: DependencyUpdateReport[],
+) => void;
 
 export const tomlFallback = (params: TomlFallbackParams): VersionFallback => ({
   readFallback(cwd: string): string | null {
     const filePath = path.resolve(cwd, params.path);
     if (!fs.existsSync(filePath)) return null;
-    const content = fs.readFileSync(filePath, 'utf8');
-    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;
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const parsed = parse(content);
+      return params.read(parsed) ?? null;
+    } catch {
+      return null;
+    }
   },
 });
 
-export const tomlUpdate = (params: TomlUpdateParams): UpdateAction => ({
+export const tomlUpdate = updateBuilder<TomlUpdateParams>({
   kind: 'toml',
-  path: params.path,
-  params,
-  required: params.required,
-  prepare(_data: UpdateActionOptions): UpdateActionResolved {
-    return {
-      kind: 'toml',
-      path: params.path,
-      params,
-      apply(report, reports, cwd) {
-        const filePath = path.resolve(cwd, params.path);
-        if (!fs.existsSync(filePath)) return;
-
-        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);
-      },
-    };
+  apply({ targetPath, params, report, reports, cwd }) {
+    const filePath = path.resolve(cwd, targetPath);
+    if (!fs.existsSync(filePath)) return;
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = parse(content);
+
+    // Safely mutate the object using the user provided callback
+    params(parsed, report, reports);
+
+    fs.writeFileSync(filePath, stringify(parsed));
   },
 });

package/src/vcs/jj.ts

@@ -7,7 +7,7 @@ export function runJj(cmd: string, cwd: string): string {
     return execSync(`jj --color=never ${cmd}`, {
       cwd,
       encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'inherit'],
+      stdio: ['ignore', 'pipe', 'ignore'],
     }).trim();
   } catch {
     return '';