relacher 0.0.4-rc.6 → 0.0.4

package/lib-types/prepare.d.ts

@@ -10,7 +10,7 @@ export declare function evaluateCommitsBump(commits: Commit[], sizes: SizePatter
 export declare function topologicalSort(items: IntermediateReport[]): IntermediateReport[];
 export declare function propagateBumps(sorted: IntermediateReport[], rules?: CascadeRules): void;
 export declare function propagateCoupledBumps(sorted: IntermediateReport[]): void;
-export declare function initReportItems(cargoDeps: DependencyConfig[], vcs: VcsProvider, sizes: SizePatterns, cwd: string): Promise<IntermediateReport[]>;
+export declare function initReportItems(cargoDeps: DependencyConfig[], vcs: VcsProvider, sizes: SizePatterns, cwd: string, excludeNestedWatches?: boolean): Promise<IntermediateReport[]>;
 export declare function prepare(cargoDeps: DependencyConfig[], vcs: VcsProvider, options?: PrepareOptions): Promise<DependencyUpdateReport[]>;
 export declare function finalizeReports(sorted: IntermediateReport[]): DependencyUpdateReport[];
 export declare function mapResolvedUpdates(updates: UpdateAction[], newVersion: string, crateCommits: Commit[], globalCommits: Commit[]): UpdateActionResolved[];

package/lib-types/types.d.ts

@@ -39,10 +39,71 @@ export interface CascadeRules {
     minor?: Record<BumpSize, BumpSize>;
     major?: Record<BumpSize, BumpSize>;
 }
+/**
+ * Configuration options for the `prepare` process.
+ */
 export interface PrepareOptions {
+    /**
+     * The directory from which to run VCS commands and locate repository files.
+     * Defaults to `process.cwd()`.
+     *
+     * @example
+     * ```typescript
+     * const options = { cwd: "/path/to/my-workspace" };
+     * ```
+     */
+    cwd?: string;
+    /**
+     * Custom regular expression patterns to match commit messages and categorize
+     * them into Semantic Versioning bump sizes (major, minor, patch, or skip).
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   sizes: {
+     *     major: { pattern: "^BREAKING CHANGE" },
+     *     minor: { pattern: "^feat|^revert" },
+     *     patch: { pattern: "^fix|^refactor" },
+     *     skip: { pattern: "^chore|^docs" }
+     *   }
+     * };
+     * ```
+     */
     sizes?: SizePatterns;
+    /**
+     * Custom cascade rules defining how semver bumps propagate upwards from
+     * dependencies to parent packages.
+     *
+     * For example, this decides if a `minor` bump in a sub-crate should trigger a
+     * `patch` bump in the workspace root package.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   cascade: {
+     *     skip: { major: "patch", minor: "patch", patch: "patch" },
+     *     patch: { major: "patch", minor: "patch", patch: "patch" },
+     *     minor: { major: "minor", minor: "minor", patch: "minor" },
+     *     major: { major: "major", minor: "major", patch: "major" }
+     *   }
+     * };
+     * ```
+     */
     cascade?: CascadeRules;
-    cwd?: string;
+    /**
+     * Automatically subtract watch paths of sub-packages when they are physically nested
+     * inside a parent package's watch path (unless they are explicitly coupled).
+     *
+     * This prevents commits made strictly inside a sub-package (such as a procedural macro
+     * crate inside its parent crate folder) from incorrectly triggering a commit-based bump
+     * on the parent package itself.
+     *
+     * @example
+     * ```typescript
+     * const options = { excludeNestedWatches: true };
+     * ```
+     */
+    excludeNestedWatches?: boolean;
 }
 export interface DependencyUpdateReport {
     name: string;

package/lib-types/vcs/git.d.ts

@@ -2,13 +2,13 @@ import type { Commit, VcsProvider } from '../types';
 export declare function runGit(cmd: string, cwd: string): string;
 export declare function findLatestTag(tags: string[], prefix: string): string | null;
 export declare function resolveGitTag(name: string, allTags: string[]): string | null;
-export declare function getGitCommits(name: string, watch: string[], allTags: string[], cwd: string): Commit[];
+export declare function getGitCommits(name: string, watch: string[], allTags: string[], cwd: string, exclude?: string[]): Commit[];
 export declare class GitVcsProvider implements VcsProvider {
     private cwd;
     private allTags;
     constructor(cwd: string);
     private getAllTags;
-    getCommits(name: string, watch: string[]): Promise<Commit[]>;
+    getCommits(name: string, watch: string[], exclude?: string[]): Promise<Commit[]>;
     getLatestTag(name?: string): Promise<string | null>;
     commit(message: string): Promise<void>;
     tag(tagName: string): Promise<void>;

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

@@ -1,6 +1,6 @@
 import type { Commit } from '../types';
 export interface VcsProvider {
-    getCommits(name: string, watch: string[]): Promise<Commit[]>;
+    getCommits(name: string, watch: string[], exclude?: string[]): Promise<Commit[]>;
     getLatestTag(name?: string): Promise<string | null>;
     commit(message: string): Promise<void>;
     tag(tagName: string): Promise<void>;

package/lib-types/vcs/jj.d.ts

@@ -2,13 +2,13 @@ import type { Commit, VcsProvider } from '../types';
 export declare function runJj(cmd: string, cwd: string): string;
 export declare function findLatestJjTag(tags: string[], prefix: string): string | null;
 export declare function resolveJjTag(name: string, allTags: string[]): string | null;
-export declare function getJjCommits(name: string, watch: string[], allTags: string[], cwd: string): Commit[];
+export declare function getJjCommits(name: string, watch: string[], allTags: string[], cwd: string, exclude?: string[]): Commit[];
 export declare class JjVcsProvider implements VcsProvider {
     private cwd;
     private allTags;
     constructor(cwd: string);
     private getAllTags;
-    getCommits(name: string, watch: string[]): Promise<Commit[]>;
+    getCommits(name: string, watch: string[], exclude?: string[]): Promise<Commit[]>;
     getLatestTag(name?: string): Promise<string | null>;
     commit(message: string): Promise<void>;
     tag(tagName: string): Promise<void>;

package/package.json

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

package/src/builder/cargo.ts

@@ -202,8 +202,8 @@ function createLockUpdate(selfName: string, hasLock: boolean) {
   }).skipIf(() => !hasLock);
 }
 
-function createWorkspaceDepUpdate(selfName: string) {
-  return tomlUpdate('Cargo.toml', (doc, report) => {
+function createWorkspaceDepUpdate(rootCargoPath: string, selfName: string) {
+  return tomlUpdate(rootCargoPath, (doc, report) => {
     const dep = doc.workspace?.dependencies?.[selfName];
     if (typeof dep === 'object' && dep.version) {
       dep.version = report.newVersion;
@@ -211,9 +211,9 @@ function createWorkspaceDepUpdate(selfName: string) {
       doc.workspace.dependencies[selfName] = report.newVersion;
     }
   }).skipIf((cwd) => {
-    // Only run this update action if the package is declared in the root workspace dependencies list
+    // Only apply if the workspace dependencies definition contains the dependency
     try {
-      const cargoPath = path.join(cwd, 'Cargo.toml');
+      const cargoPath = path.resolve(cwd, rootCargoPath);
       if (fs.existsSync(cargoPath)) {
         const doc = parse(fs.readFileSync(cargoPath, 'utf8')) as any;
         return !doc.workspace?.dependencies?.[selfName];
@@ -226,10 +226,10 @@ function createWorkspaceDepUpdate(selfName: string) {
 function buildCrateConfig(
   info: any,
   workspaceRoot: string,
+  rootCargoPath: 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);
@@ -246,7 +246,7 @@ function buildCrateConfig(
     updates: [
       createSelfUpdate(relCargo, info.name),
       createLockUpdate(info.name, hasLock),
-      createWorkspaceDepUpdate(info.name),
+      createWorkspaceDepUpdate(rootCargoPath, info.name),
     ],
   };
 }
@@ -280,13 +280,28 @@ export function cargoDeps(cwd: string, options?: CargoBuilderOptions): Dependenc
     const scanner = scanWorkspace(workspaceRoot, rootDoc);
     const hasLock = fs.existsSync(path.join(workspaceRoot, 'Cargo.lock'));
     const localNames = new Set(scanner.crateInfos.map((c) => c.name));
+
+    // Calculate relative path from executing cwd to the workspace root Cargo.toml
+    const relWorkspaceRoot = path.relative(cwd, workspaceRoot);
+    const rootCargoPath = relWorkspaceRoot
+      ? path.join(relWorkspaceRoot, 'Cargo.toml')
+      : 'Cargo.toml';
+
     const configs = scanner.crateInfos.map((info) =>
-      buildCrateConfig(info, workspaceRoot, localNames, hasLock, scanner.workspaceDeps, options),
+      buildCrateConfig(
+        info,
+        workspaceRoot,
+        rootCargoPath,
+        localNames,
+        hasLock,
+        scanner.workspaceDeps,
+      ),
     );
     const list = decorateList(configs) as any;
     list.couple = (a: string, b: string) => (coupleConfigs(configs, a, b) ? list : list);
     return list;
-  } catch {
+  } catch (e) {
+    console.warn(e);
     return decorateList([]);
   }
 }

package/src/prepare.ts

@@ -163,6 +163,7 @@ export async function initReportItems(
   vcs: VcsProvider,
   sizes: SizePatterns,
   cwd: string,
+  excludeNestedWatches = false,
 ): Promise<IntermediateReport[]> {
   const reports: IntermediateReport[] = [];
   for (const dep of cargoDeps) {
@@ -170,7 +171,38 @@ export async function initReportItems(
     const isMissingVersion = currentVersion === null;
     const actualVersion = currentVersion || '0.0.0';
 
-    const commits = await vcs.getCommits(dep.name, dep.watch || []);
+    const exclude: string[] = [];
+    const watchPaths = dep.watch || [];
+
+    // Only compute exclusions if the option is explicitly enabled
+    if (excludeNestedWatches) {
+      for (const other of cargoDeps) {
+        if (other.name === dep.name) continue;
+
+        // Check if coupled
+        const isCoupled =
+          ((dep as any).coupled || []).includes(other.name) ||
+          ((other as any).coupled || []).includes(dep.name);
+        if (isCoupled) continue;
+
+        const otherWatchPaths = other.watch || [];
+        for (const wp of watchPaths) {
+          const wpNorm = path.normalize(wp).replace(/\\/g, '/');
+          for (const owp of otherWatchPaths) {
+            const owpNorm = path.normalize(owp).replace(/\\/g, '/');
+            const relative = path.relative(wpNorm, owpNorm);
+
+            const isNested =
+              relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+            if (isNested) {
+              exclude.push(owp);
+            }
+          }
+        }
+      }
+    }
+
+    const commits = await vcs.getCommits(dep.name, watchPaths, exclude);
     const selfBump = evaluateCommitsBump(commits, sizes);
 
     let isErroneous = isMissingVersion;
@@ -211,7 +243,7 @@ export async function prepare(
 ): Promise<DependencyUpdateReport[]> {
   const cwd = options.cwd || process.cwd();
   const sizes = options.sizes || defaultSizes;
-  const items = await initReportItems(cargoDeps, vcs, sizes, cwd);
+  const items = await initReportItems(cargoDeps, vcs, sizes, cwd, options.excludeNestedWatches);
   const sorted = topologicalSort(items);
   propagateBumps(sorted, options.cascade);
   propagateCoupledBumps(sorted);

package/src/types.ts

@@ -47,10 +47,74 @@ export interface CascadeRules {
   major?: Record<BumpSize, BumpSize>;
 }
 
+/**
+ * Configuration options for the `prepare` process.
+ */
 export interface PrepareOptions {
+  /**
+   * The directory from which to run VCS commands and locate repository files.
+   * Defaults to `process.cwd()`.
+   *
+   * @example
+   * ```typescript
+   * const options = { cwd: "/path/to/my-workspace" };
+   * ```
+   */
+  cwd?: string;
+
+  /**
+   * Custom regular expression patterns to match commit messages and categorize
+   * them into Semantic Versioning bump sizes (major, minor, patch, or skip).
+   *
+   * @example
+   * ```typescript
+   * const options = {
+   *   sizes: {
+   *     major: { pattern: "^BREAKING CHANGE" },
+   *     minor: { pattern: "^feat|^revert" },
+   *     patch: { pattern: "^fix|^refactor" },
+   *     skip: { pattern: "^chore|^docs" }
+   *   }
+   * };
+   * ```
+   */
   sizes?: SizePatterns;
+
+  /**
+   * Custom cascade rules defining how semver bumps propagate upwards from
+   * dependencies to parent packages.
+   *
+   * For example, this decides if a `minor` bump in a sub-crate should trigger a
+   * `patch` bump in the workspace root package.
+   *
+   * @example
+   * ```typescript
+   * const options = {
+   *   cascade: {
+   *     skip: { major: "patch", minor: "patch", patch: "patch" },
+   *     patch: { major: "patch", minor: "patch", patch: "patch" },
+   *     minor: { major: "minor", minor: "minor", patch: "minor" },
+   *     major: { major: "major", minor: "major", patch: "major" }
+   *   }
+   * };
+   * ```
+   */
   cascade?: CascadeRules;
-  cwd?: string;
+
+  /**
+   * Automatically subtract watch paths of sub-packages when they are physically nested
+   * inside a parent package's watch path (unless they are explicitly coupled).
+   *
+   * This prevents commits made strictly inside a sub-package (such as a procedural macro
+   * crate inside its parent crate folder) from incorrectly triggering a commit-based bump
+   * on the parent package itself.
+   *
+   * @example
+   * ```typescript
+   * const options = { excludeNestedWatches: true };
+   * ```
+   */
+  excludeNestedWatches?: boolean;
 }
 
 export interface DependencyUpdateReport {

package/src/updater/changelog.ts

@@ -66,9 +66,9 @@ export function defaultChangelogTemplate({ version, date, commits }: ChangelogCo
 
   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`;
+  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/vcs/git.ts

@@ -43,11 +43,17 @@ export function getGitCommits(
   watch: string[],
   allTags: string[],
   cwd: string,
+  exclude: string[] = [],
 ): Commit[] {
   const lastTag = resolveGitTag(name, allTags);
-  const watchPaths = watch.join(' ');
   const range = lastTag ? `${lastTag}..HEAD` : 'HEAD';
 
+  const paths = [...watch];
+  if (exclude && exclude.length > 0) {
+    paths.push(...exclude.map((e) => `:(exclude)${e}`));
+  }
+
+  const watchPaths = paths.join(' ');
   const gitCmd = watchPaths
     ? `git log ${range} --no-show-signature --format='%H|%an|%ad|%s' --date=short -- ${watchPaths}`
     : `git log ${range} --no-show-signature --format='%H|%an|%ad|%s' --date=short`;
@@ -99,9 +105,9 @@ export class GitVcsProvider implements VcsProvider {
     return this.allTags;
   }
 
-  async getCommits(name: string, watch: string[]): Promise<Commit[]> {
+  async getCommits(name: string, watch: string[], exclude?: string[]): Promise<Commit[]> {
     const tags = this.getAllTags();
-    return getGitCommits(name, watch, tags, this.cwd);
+    return getGitCommits(name, watch, tags, this.cwd, exclude);
   }
 
   async getLatestTag(name?: string): Promise<string | null> {

package/src/vcs/index.ts

@@ -1,7 +1,7 @@
 import type { Commit } from '../types';
 
 export interface VcsProvider {
-  getCommits(name: string, watch: string[]): Promise<Commit[]>;
+  getCommits(name: string, watch: string[], exclude?: string[]): Promise<Commit[]>;
   getLatestTag(name?: string): Promise<string | null>;
   commit(message: string): Promise<void>;
   tag(tagName: string): Promise<void>;

package/src/vcs/jj.ts

@@ -47,10 +47,18 @@ export function getJjCommits(
   watch: string[],
   allTags: string[],
   cwd: string,
+  exclude: string[] = [],
 ): Commit[] {
   const lastTag = resolveJjTag(name, allTags);
 
-  const range = lastTag ? `"${lastTag}"..@ & ~root()` : `::@ & ~root()`;
+  let range = lastTag ? `"${lastTag}"..@ & ~root()` : `::@ & ~root()`;
+
+  // Append negative path constraints to the revset range
+  if (exclude && exclude.length > 0) {
+    for (const ext of exclude) {
+      range += ` & ~file("${ext}")`;
+    }
+  }
 
   const template =
     'commit_id.short(40) ++ "|" ++ author.name() ++ "|" ++ author.timestamp().format("%Y-%m-%d") ++ "|" ++ description.first_line() ++ "\\n"';
@@ -111,9 +119,9 @@ export class JjVcsProvider implements VcsProvider {
     return this.allTags;
   }
 
-  async getCommits(name: string, watch: string[]): Promise<Commit[]> {
+  async getCommits(name: string, watch: string[], exclude?: string[]): Promise<Commit[]> {
     const tags = this.getAllTags();
-    return getJjCommits(name, watch, tags, this.cwd);
+    return getJjCommits(name, watch, tags, this.cwd, exclude);
   }
 
   async getLatestTag(name?: string): Promise<string | null> {