relacher 0.0.4-rc.0 → 0.0.4-rc.2

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

@@ -2,12 +2,4 @@ import { type DependencyList } from './shared';
 export interface CargoBuilderOptions {
     syncWorkspaceDeps?: boolean;
 }
-/**
- * Loads a single Cargo project from a target Cargo.toml.
- */
-export declare function cargoProject(cwd: string): DependencyList;
-/**
- * Loads a Cargo workspace, tracking member paths, dependency links, and recursive nested paths.
- */
-export declare function cargoWorkspace(cwd: string, options?: CargoBuilderOptions): DependencyList;
 export declare function cargoDeps(cwd: string, options?: CargoBuilderOptions): DependencyList;

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

@@ -17,6 +17,8 @@ export interface UpdateAction {
     required?: boolean;
     params: any;
     prepare(data: UpdateActionOptions): UpdateActionResolved;
+    skipIf(fn: (cwd: string) => boolean): this;
+    _skipIf(cwd: string): boolean;
 }
 export interface VersionFallback {
     readFallback(cwd: string): string | null;
@@ -44,13 +46,5 @@ type UpdateBuilderParams<T, K = undefined> = {
 };
 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;
-};
+}) => UpdateAction;
 export {};

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

@@ -6,13 +6,5 @@ export type ChangelogUpdateParams = {
 };
 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;
-};
+}) => import("./builder").UpdateAction;
 export declare function defaultChangelogTemplate({ version, date, commits }: ChangelogContext): string;

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

@@ -8,12 +8,4 @@ export type JsonUpdateParams = (parsed: any, report: DependencyUpdateReport, rep
 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;
-};
+}) => import("./builder").UpdateAction;

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

@@ -11,12 +11,4 @@ export type RegexUpdateParams = {
 export declare const regexFallback: (params: RegexFallbackParams) => VersionFallback;
 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;
-};
+}) => import("./builder").UpdateAction;

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

@@ -8,12 +8,4 @@ export type TomlUpdateParams = (parsed: any, report: DependencyUpdateReport, rep
 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;
-};
+}) => import("./builder").UpdateAction;

package/package.json

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

package/src/builder/cargo.ts

@@ -12,244 +12,248 @@ export interface CargoBuilderOptions {
   syncWorkspaceDeps?: boolean;
 }
 
-/**
- * Loads a single Cargo project from a target Cargo.toml.
- */
-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)) {
-    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
+interface PathDep {
+  name: string;
+  path: string;
+}
+
+function isWorkspace(cargoPath: string): boolean {
+  try {
+    const doc = parse(fs.readFileSync(cargoPath, 'utf8')) as any;
+    return !!doc?.workspace;
+  } catch {
+    return false;
+  }
+}
+
+function checkDir(dir: string): { isRoot: boolean; hasCargo: boolean } {
+  const cargoPath = path.join(dir, 'Cargo.toml');
+  const hasCargo = fs.existsSync(cargoPath);
+  return { isRoot: hasCargo && isWorkspace(cargoPath), hasCargo };
+}
+
+function findCargoWorkspaceRoot(cwd: string): string {
+  let current = path.resolve(cwd);
+  let bestRoot = current;
+  while (true) {
+    const { isRoot, hasCargo } = checkDir(current);
+    if (isRoot) return current;
+    if (hasCargo) bestRoot = current;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return bestRoot;
+}
+
+function getPathFromVal(name: string, val: any, wsDeps: Record<string, any>): string | undefined {
+  if (val && typeof val === 'object') {
+    if (val.path) return val.path;
+    if (val.workspace === true && wsDeps[name]?.path) {
+      return wsDeps[name].path;
     }
   }
+  return undefined;
+}
 
-  return decorateList(configs);
+function collectDepsFromBlock(block: any, wsDeps: Record<string, any>): PathDep[] {
+  if (!block || typeof block !== 'object') return [];
+  const list: PathDep[] = [];
+  for (const [name, val] of Object.entries(block)) {
+    const p = getPathFromVal(name, val, wsDeps);
+    if (p) list.push({ name, path: p });
+  }
+  return list;
 }
 
-/**
- * Loads a Cargo workspace, tracking member paths, dependency links, and recursive nested paths.
- */
-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>();
+function collectTargetDeps(doc: any, wsDeps: Record<string, any>): PathDep[] {
+  if (!doc.target || typeof doc.target !== 'object') return [];
+  const list: PathDep[] = [];
+  for (const targetValue of Object.values(doc.target)) {
+    if (targetValue && typeof targetValue === 'object') {
+      list.push(...collectDepsFromBlock((targetValue as any).dependencies, wsDeps));
+      list.push(...collectDepsFromBlock((targetValue as any)['dev-dependencies'], wsDeps));
+      list.push(...collectDepsFromBlock((targetValue as any)['build-dependencies'], wsDeps));
+    }
+  }
+  return list;
+}
+
+function extractPathDependencies(doc: any, wsDeps: Record<string, any> = {}): PathDep[] {
+  return [
+    ...collectDepsFromBlock(doc.dependencies, wsDeps),
+    ...collectDepsFromBlock(doc['dev-dependencies'], wsDeps),
+    ...collectDepsFromBlock(doc['build-dependencies'], wsDeps),
+    ...collectTargetDeps(doc, wsDeps),
+  ];
+}
+
+class CrateScanner {
+  workspaceRoot: string;
+  workspaceDeps: Record<string, any>;
+  discoveredPaths = new Set<string>();
+  crateInfos: { name: string; memberPath: string; doc: any }[] = [];
+
+  constructor(workspaceRoot: string, workspaceDeps: Record<string, any>) {
+    this.workspaceRoot = workspaceRoot;
+    this.workspaceDeps = workspaceDeps;
+  }
 
-  if (fs.existsSync(rootCargo)) {
+  registerCrate(p: string) {
+    const absPath = path.resolve(this.workspaceRoot, p);
+    if (this.discoveredPaths.has(absPath)) return;
+    this.discoveredPaths.add(absPath);
+    const cargoPath = path.join(absPath, 'Cargo.toml');
+    if (!fs.existsSync(cargoPath)) return;
     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 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++;
-        }
-
-        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);
-            }
-          }
-
-          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;
-                }
-              }),
-            );
-          }
-
-          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;
-                  }
-                }
-              }),
-            );
-          }
-
-          configs.push({
-            name: info.name,
-            watch: [posixRelativePath || '.'],
-            depends,
-            versionFallback: tomlFallback({
-              path: relativeCargo,
-              read: (doc) => doc.package?.version,
-            }),
-            updates,
-          });
-        }
+      const doc = parse(fs.readFileSync(cargoPath, 'utf8')) as any;
+      if (doc.package?.name) {
+        this.crateInfos.push({ name: doc.package.name, memberPath: absPath, doc });
       }
-    } catch {
-      // Ignore parse error
+    } catch { }
+  }
+}
+
+function expandGlob(workspaceRoot: string, member: string): string[] {
+  const globPath = path.join(workspaceRoot, member);
+  if (!globPath.endsWith('*')) return [path.join(globPath, 'Cargo.toml')];
+  const dir = path.dirname(globPath);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).map((d) => path.join(dir, d, 'Cargo.toml'));
+}
+
+function registerWorkspaceMembers(scanner: CrateScanner, rootDoc: any) {
+  if (rootDoc.package?.name) {
+    scanner.registerCrate(scanner.workspaceRoot);
+  }
+  const members = rootDoc.workspace?.members;
+  if (!Array.isArray(members)) return;
+  for (const member of members) {
+    const paths = expandGlob(scanner.workspaceRoot, member).filter(fs.existsSync);
+    paths.forEach((p) => scanner.registerCrate(path.dirname(p)));
+  }
+}
+
+function runRecursiveDiscovery(scanner: CrateScanner) {
+  let i = 0;
+  while (i < scanner.crateInfos.length) {
+    const info = scanner.crateInfos[i]!;
+    const foundDeps = extractPathDependencies(info.doc, scanner.workspaceDeps);
+    for (const dep of foundDeps) {
+      const fullDepPath = path.resolve(info.memberPath, dep.path);
+      scanner.registerCrate(fullDepPath);
     }
+    i++;
   }
+}
 
-  return decorateList(configs);
+function updateBlockEntry(block: any, depName: string, newVersion: string) {
+  const dep = block[depName];
+  if (dep && typeof dep === 'object' && dep.version) {
+    dep.version = newVersion;
+  } else if (typeof dep === 'string') {
+    block[depName] = newVersion;
+  }
 }
 
-export function cargoDeps(cwd: string, options?: CargoBuilderOptions): DependencyList {
-  const rootCargo = path.join(cwd, 'Cargo.toml');
-  if (fs.existsSync(rootCargo)) {
-    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);
+function syncDeps(block: any, reports: any[], selfName: string) {
+  if (!block || typeof block !== 'object') return;
+  for (const r of reports) {
+    if (r.name !== selfName && block[r.name]) {
+      updateBlockEntry(block, r.name, r.newVersion);
+    }
+  }
+}
+
+function syncAllBlocks(doc: any, reports: any[], selfName: string) {
+  syncDeps(doc.dependencies, reports, selfName);
+  syncDeps(doc['dev-dependencies'], reports, selfName);
+  syncDeps(doc['build-dependencies'], reports, selfName);
+  if (doc.target && typeof doc.target === 'object') {
+    for (const targetVal of Object.values(doc.target)) {
+      if (targetVal && typeof targetVal === 'object') {
+        syncDeps((targetVal as any).dependencies, reports, selfName);
+        syncDeps((targetVal as any)['dev-dependencies'], reports, selfName);
+        syncDeps((targetVal as any)['build-dependencies'], reports, selfName);
       }
-    } catch {
-      // Fallback below
     }
   }
-  return decorateList([]);
+}
+
+function createSelfUpdate(relativeCargo: string, selfName: string) {
+  return tomlUpdate(relativeCargo, (doc, report, reports) => {
+    if (doc.package) {
+      doc.package.version = report.newVersion;
+    }
+    syncAllBlocks(doc, reports, selfName);
+  });
+}
+
+function createLockUpdate(selfName: string, hasLock: boolean) {
+  return tomlUpdate('Cargo.lock', (doc, report) => {
+    if (Array.isArray(doc.package)) {
+      const pkg = doc.package.find((p: any) => p.name === selfName && !p.source && !p.checksum);
+      if (pkg) pkg.version = report.newVersion;
+    }
+  }).skipIf(() => !hasLock);
+}
+
+function createWorkspaceDepUpdate(selfName: string, options?: CargoBuilderOptions) {
+  return tomlUpdate('Cargo.toml', (doc, report) => {
+    const dep = doc.workspace?.dependencies?.[selfName];
+    if (typeof dep === 'object' && dep.version) {
+      dep.version = report.newVersion;
+    } else if (typeof dep === 'string') {
+      doc.workspace.dependencies[selfName] = report.newVersion;
+    }
+  }).skipIf(() => !options?.syncWorkspaceDeps);
+}
+
+function buildCrateConfig(
+  info: any,
+  workspaceRoot: string,
+  localNames: Set<string>,
+  hasLock: boolean,
+  wsDeps: Record<string, any>,
+  options?: CargoBuilderOptions,
+): DependencyConfig {
+  const relPath = path.relative(workspaceRoot, info.memberPath);
+  const posixPath = relPath.split(path.sep).join(path.posix.sep);
+  const relCargo = posixPath ? path.posix.join(posixPath, 'Cargo.toml') : 'Cargo.toml';
+  const depends = extractPathDependencies(info.doc, wsDeps)
+    .map((fd) => fd.name)
+    .filter((name) => localNames.has(name) && name !== info.name);
+
+  return {
+    name: info.name,
+    watch: [posixPath || '.'],
+    depends,
+    versionFallback: tomlFallback({ path: relCargo, read: (doc) => doc.package?.version }),
+    updates: [
+      createSelfUpdate(relCargo, info.name),
+      createLockUpdate(info.name, hasLock),
+      createWorkspaceDepUpdate(info.name, options),
+    ],
+  };
+}
+
+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 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);
+  } catch {
+    return decorateList([]);
+  }
 }

package/src/builder/pnpm.ts

@@ -29,7 +29,7 @@ export function pnpmProject(cwd: string): DependencyList {
           updates: [
             jsonUpdate('package.json', (parsed, report) => {
               parsed.version = report.newVersion;
-            }),
+            }).skipIf((cwd) => !fs.existsSync(path.join(cwd, 'package.json'))),
           ],
         });
       }
@@ -173,7 +173,7 @@ export function pnpmWorkspace(cwd: string): DependencyList {
               }
             }
           }
-        }),
+        }).skipIf((cwd) => !fs.existsSync(path.join(cwd, relativePJson))),
       ],
     });
   }

package/src/prepare.ts

@@ -33,12 +33,10 @@ export async function getCurrentVersion(
   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}/`)) {
@@ -48,7 +46,6 @@ export async function getCurrentVersion(
     return { version: version.replace(/^v/, ''), isFallback: false };
   }
 
-  // 2. Resolve via user-defined fallback
   if (dep.versionFallback) {
     return { version: dep.versionFallback.readFallback(cwd), isFallback: true };
   }
@@ -145,6 +142,9 @@ export async function initReportItems(
 
     let isErroneous = isMissingVersion;
     for (const u of dep.updates || []) {
+      if (u._skipIf?.(cwd)) {
+        continue;
+      }
       if (u.required) {
         const filePath = path.resolve(cwd, u.path);
         if (!fs.existsSync(filePath)) {

package/src/updater/builder.ts

@@ -20,6 +20,8 @@ export interface UpdateAction {
   required?: boolean;
   params: any;
   prepare(data: UpdateActionOptions): UpdateActionResolved;
+  skipIf(fn: (cwd: string) => boolean): this;
+  _skipIf(cwd: string): boolean;
 }
 
 export interface VersionFallback {
@@ -33,7 +35,7 @@ export type ApplyActionFnArgs<T, K = undefined> = {
   report: DependencyUpdateReport;
   reports: DependencyUpdateReport[];
   cwd: string;
-  preparedData: K; // Added preparedData to the arguments
+  preparedData: K;
 };
 
 type ApplyActionFn<T, K = undefined> = (args: ApplyActionFnArgs<T, K>) => void;
@@ -48,36 +50,52 @@ type PrepareActionFn<T, K> = (args: PrepareActionFnArgs<T>) => K;
 
 type UpdateBuilderParams<T, K = undefined> = {
   kind: string;
-  apply: ApplyActionFn<T, K>; // Passed K here
+  apply: ApplyActionFn<T, K>;
   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;
+    (targetPath: string, params: T & { required?: boolean }) => {
+      let skipIfCallback: ((cwd: string) => boolean) | undefined;
 
-        return {
-          kind,
-          targetPath,
-          params,
-          preparedData,
-          apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string) {
-            apply({
-              preparedData,
-              targetPath,
-              params,
-              options,
-              report,
-              reports,
-              cwd,
-            });
-          },
-        };
-      },
-    });
+      const action: UpdateAction = {
+        kind,
+        path: targetPath,
+        params,
+        required: params.required,
+        skipIf(fn: (cwd: string) => boolean) {
+          skipIfCallback = fn;
+          return this;
+        },
+        _skipIf(cwd: string) {
+          return skipIfCallback ? skipIfCallback(cwd) : false;
+        },
+        prepare(options: UpdateActionOptions): UpdateActionResolved {
+          const preparedData = prepare?.({ params, targetPath, options }) as K;
+
+          return {
+            kind,
+            targetPath,
+            params,
+            preparedData,
+            apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string) {
+              if (skipIfCallback?.(cwd)) {
+                return;
+              }
+              apply({
+                preparedData,
+                targetPath,
+                params,
+                options,
+                report,
+                reports,
+                cwd,
+              });
+            },
+          };
+        },
+      };
+
+      return action;
+    };

package/src/updater/index.ts

@@ -3,4 +3,3 @@ export * from './changelog';
 export * from './json';
 export * from './regex';
 export * from './toml';
-