relacher 0.0.4 → 0.0.5-rc.0

package/lib-types/index.d.ts

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

package/lib-types/prepare.d.ts

@@ -1,16 +1,12 @@
-import type { BumpSize, Commit, VcsProvider, DependencyConfig, DependencyUpdateReport, IntermediateReport, PrepareOptions, SizePatterns, CascadeRules } from './types';
+import { Effect } from 'effect';
+import type { Commit, DependencyConfig, DependencyUpdateReport, IntermediateReport, PrepareOptions } from './types';
 import type { UpdateAction, UpdateActionResolved } from './updater';
-export declare function bumpVersion(version: string, size: BumpSize): string;
-export declare function getCurrentVersion(dep: DependencyConfig, vcs: VcsProvider, cwd: string): Promise<{
-    version: string | null;
-    isFallback: boolean;
-}>;
-export declare function matchBumpSize(message: string, sizes: SizePatterns): BumpSize;
-export declare function evaluateCommitsBump(commits: Commit[], sizes: SizePatterns): BumpSize;
+import { type VersionManager } from './versioning';
+import type { BumpSize } from './versioning/types';
+export declare function isBumpSizeMatch(actual: BumpSize, pattern: BumpSize): boolean;
+export declare function isUpdateActive(bump: BumpSize, onlyOn?: BumpSize[]): boolean;
 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, 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[];
+export declare function initReportItems(cargoDeps: DependencyConfig[], cwd: string, excludeNestedWatches?: boolean): Effect.Effect<IntermediateReport[], Error, VersionManager>;
+export declare function prepare(cargoDeps: DependencyConfig[], options?: PrepareOptions): Effect.Effect<DependencyUpdateReport[], Error, VersionManager>;
+export declare function finalizeReports(sorted: IntermediateReport[], isRCMode: boolean, versionManager?: VersionManager): DependencyUpdateReport[];
+export declare function mapResolvedUpdates(updates: UpdateAction[], newVersion: string, crateCommits: Commit[], globalCommits: Commit[], isRCMode?: boolean, bump?: BumpSize, commitsSincePreRelease?: Commit[]): UpdateActionResolved[];

package/lib-types/run.d.ts

@@ -1,12 +1,14 @@
-import type { DependencyUpdateReport, VcsProvider } from './types';
+import { Effect } from 'effect';
+import type { DependencyUpdateReport } from './types';
+import { type VcsProvider } from './vcs';
 /**
  * Builds the multi-line commit message showcasing version bumps, included commits,
  * cascade triggers, and first-release indicators.
  */
 export declare function generateCommitMessage(reports: DependencyUpdateReport[]): string | null;
 /**
- * Applies calculated updates to files on disk, stages, commits, and tags using the provided VcsProvider.
+ * Applies calculated updates to files on disk, stages, commits, and tags using the VcsProvider from context.
  */
-export declare function run(reports: DependencyUpdateReport[], vcs: VcsProvider, options: {
+export declare function run(reports: DependencyUpdateReport[], options: {
     cwd: string;
-}): Promise<void>;
+}): Effect.Effect<void, Error, VcsProvider>;

package/lib-types/types.d.ts

@@ -1,6 +1,5 @@
 import type { UpdateAction, UpdateActionResolved, VersionFallback } from './updater';
-import type { VcsProvider } from './vcs';
-export type BumpSize = 'major' | 'minor' | 'patch' | 'skip';
+import type { BumpSize } from './versioning/types';
 export interface Commit {
     hash: string;
     shortHash: string;
@@ -16,6 +15,7 @@ export interface ChangelogContext {
     version: string;
     date: string;
     commits: Commit[];
+    commitsSincePreRelease?: Commit[];
 }
 export interface DependencyConfig {
     name: string;
@@ -24,96 +24,22 @@ export interface DependencyConfig {
     versionFallback?: VersionFallback;
     depends?: string[];
 }
-export interface PatternConfig {
-    pattern: string;
-}
-export interface SizePatterns {
-    major: PatternConfig;
-    minor: PatternConfig;
-    patch: PatternConfig;
-    skip: PatternConfig;
-}
-export interface CascadeRules {
-    skip?: Record<BumpSize, BumpSize>;
-    patch?: Record<BumpSize, BumpSize>;
-    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;
-    /**
-     * 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;
     currentVersion: string;
+    lastStableVersion?: string | null;
     newVersion: string;
     bump: BumpSize;
     originalBump?: BumpSize;
     commits: Commit[];
+    commitsSincePreRelease?: Commit[];
     updates: UpdateActionResolved[];
     depends?: string[];
+    skipTag?: boolean;
     isErroneous?: boolean;
     isFirstRelease?: boolean;
 }
@@ -122,11 +48,12 @@ export interface IntermediateReport {
     currentVersion: string;
     newVersion: string;
     bump: BumpSize;
+    lastStableVersion?: string | null;
     originalBump?: BumpSize;
     commits: Commit[];
+    commitsSincePreRelease?: Commit[];
     updates: UpdateAction[];
     depends: string[];
     isErroneous?: boolean;
     isFirstRelease?: boolean;
 }
-export type { VcsProvider };

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

@@ -1,4 +1,5 @@
 import type { Commit, DependencyUpdateReport } from '../types';
+import type { BumpSize } from '../versioning/types';
 export type UpdateActionOptions = {
     newVersion: string;
     globalCommits: Commit[];
@@ -15,6 +16,7 @@ export interface UpdateAction {
     kind: string;
     path: string;
     required?: boolean;
+    onlyOn?: BumpSize[];
     params: any;
     prepare(data: UpdateActionOptions): UpdateActionResolved;
     skipIf(fn: (cwd: string) => boolean): this;
@@ -39,12 +41,11 @@ export type PrepareActionFnArgs<T> = {
     options: UpdateActionOptions;
 };
 type PrepareActionFn<T, K> = (args: PrepareActionFnArgs<T>) => K;
+type Layered<T> = Pick<UpdateAction, 'onlyOn' | 'required'> & T;
 type UpdateBuilderParams<T, K = undefined> = {
     kind: string;
-    apply: ApplyActionFn<T, K>;
-    prepare?: PrepareActionFn<T, K>;
+    apply: ApplyActionFn<Layered<T>, K>;
+    prepare?: PrepareActionFn<Layered<T>, K>;
 };
-export declare const updateBuilder: <T, K = undefined>({ kind, apply, prepare }: UpdateBuilderParams<T, K>) => (targetPath: string, params: T & {
-    required?: boolean;
-}) => UpdateAction;
+export declare const updateBuilder: <T, K = undefined>({ kind, apply, prepare }: UpdateBuilderParams<T, K>) => (targetPath: string, params: Layered<T>) => UpdateAction;
 export {};

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

@@ -2,9 +2,6 @@ import { type ChangelogContext } from '../types';
 export type ChangelogUpdateParams = {
     global?: boolean;
     template?: (ctx: ChangelogContext) => string;
-    required?: boolean;
 };
-export declare const changelogUpdate: (targetPath: string, params: ChangelogUpdateParams & {
-    required?: boolean;
-}) => import("./builder").UpdateAction;
+export declare const changelogUpdate: (targetPath: string, params: Pick<import("./builder").UpdateAction, "onlyOn" | "required"> & ChangelogUpdateParams) => import("./builder").UpdateAction;
 export declare function defaultChangelogTemplate({ version, date, commits }: ChangelogContext): string;

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

@@ -6,6 +6,4 @@ export type JsonFallbackParams = {
 };
 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;
-}) => import("./builder").UpdateAction;
+export declare const jsonUpdate: (targetPath: string, params: Pick<import("./builder").UpdateAction, "onlyOn" | "required"> & JsonUpdateParams) => import("./builder").UpdateAction;

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

@@ -6,9 +6,6 @@ export type RegexFallbackParams = {
 export type RegexUpdateParams = {
     search: string;
     replace: string;
-    required?: boolean;
 };
 export declare const regexFallback: (params: RegexFallbackParams) => VersionFallback;
-export declare const regexUpdate: (targetPath: string, params: RegexUpdateParams & {
-    required?: boolean;
-}) => import("./builder").UpdateAction;
+export declare const regexUpdate: (targetPath: string, params: Pick<import("./builder").UpdateAction, "onlyOn" | "required"> & RegexUpdateParams) => import("./builder").UpdateAction;

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

@@ -6,6 +6,4 @@ export type TomlFallbackParams = {
 };
 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;
-}) => import("./builder").UpdateAction;
+export declare const tomlUpdate: (targetPath: string, params: Pick<import("./builder").UpdateAction, "onlyOn" | "required"> & TomlUpdateParams) => import("./builder").UpdateAction;

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

@@ -6,6 +6,4 @@ export type YamlFallbackParams = {
 };
 export type YamlUpdateParams = (parsed: any, report: DependencyUpdateReport, reports: DependencyUpdateReport[]) => void;
 export declare const yamlFallback: (params: YamlFallbackParams) => VersionFallback;
-export declare const yamlUpdate: (targetPath: string, params: YamlUpdateParams & {
-    required?: boolean;
-}) => import("./builder").UpdateAction;
+export declare const yamlUpdate: (targetPath: string, params: Pick<import("./builder").UpdateAction, "onlyOn" | "required"> & YamlUpdateParams) => import("./builder").UpdateAction;

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

@@ -1,15 +1,9 @@
-import type { Commit, VcsProvider } from '../types';
-export declare function runGit(cmd: string, cwd: string): string;
+import { Effect, Layer } from 'effect';
+import type { Commit } from '../types';
+import { type VcsProvider } from './index';
+export declare function runGit(cmd: string, cwd: string): Effect.Effect<string, never>;
 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, exclude?: string[]): Commit[];
-export declare class GitVcsProvider implements VcsProvider {
-    private cwd;
-    private allTags;
-    constructor(cwd: string);
-    private getAllTags;
-    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>;
-}
+export declare function getGitCommits(name: string, watch: string[], allTags: string[], cwd: string, exclude?: string[]): Effect.Effect<Commit[], never>;
+export declare function makeGitVcsProvider(cwd: string): VcsProvider;
+export declare const GitVcsProviderLive: (cwd: string) => Layer.Layer<VcsProvider, never, never>;

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

@@ -1,9 +1,11 @@
+import { Context, Effect } from 'effect';
 import type { Commit } from '../types';
 export interface VcsProvider {
-    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>;
+    readonly getCommits: (name: string, watch: string[], exclude?: string[]) => Effect.Effect<Commit[], Error>;
+    readonly getLatestTag: (name?: string) => Effect.Effect<string | null, Error>;
+    readonly commit: (message: string) => Effect.Effect<void, Error>;
+    readonly tag: (tagName: string) => Effect.Effect<void, Error>;
 }
+export declare const VcsProviderService: Context.Service<VcsProvider, VcsProvider>;
 export * from './git';
 export * from './jj';

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

@@ -1,15 +1,11 @@
-import type { Commit, VcsProvider } from '../types';
-export declare function runJj(cmd: string, cwd: string): string;
+import { Effect, Layer } from 'effect';
+import type { Commit } from '../types';
+import { type VcsProvider } from './index';
+export declare function runJj(cmd: string, cwd: string, opts?: {
+    withStdio: boolean;
+}): Effect.Effect<string, never>;
 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, exclude?: string[]): Commit[];
-export declare class JjVcsProvider implements VcsProvider {
-    private cwd;
-    private allTags;
-    constructor(cwd: string);
-    private getAllTags;
-    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>;
-}
+export declare function getJjCommits(name: string, watch: string[], allTags: string[], cwd: string, exclude?: string[]): Effect.Effect<Commit[], never>;
+export declare function makeJjVcsProvider(cwd: string): VcsProvider;
+export declare const JjVcsProviderLive: (cwd: string) => Layer.Layer<VcsProvider, never, never>;

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

@@ -0,0 +1,21 @@
+import { Context, Effect } from 'effect';
+import type { Commit, DependencyConfig, IntermediateReport } from '../types';
+import type { BumpSize } from './types';
+export interface VersionManager {
+    readonly isRCMode: boolean;
+    readonly tagPrereleases: boolean;
+    readonly getCurrentVersion: (dep: DependencyConfig, cwd: string) => Effect.Effect<{
+        version: string | null;
+        isFallback: boolean;
+        lastStableVersion?: string | null;
+    }, Error>;
+    readonly getCommits: (dep: DependencyConfig, excludePaths: string[]) => Effect.Effect<Commit[], Error>;
+    readonly evaluateCommitsBump: (commits: Commit[]) => BumpSize;
+    readonly propagateBumps: (sorted: IntermediateReport[]) => void;
+    readonly propagateCoupledBumps: (sorted: IntermediateReport[]) => void;
+    readonly bumpVersion: (currentVersion: string, size: BumpSize) => string;
+    readonly shouldTag: (version: string) => boolean;
+}
+export declare const VersionManagerService: Context.Service<VersionManager, VersionManager>;
+export * from './vcs-version-manager';
+export * from './rc-version-manager';

package/lib-types/versioning/rc-version-manager.d.ts

@@ -0,0 +1,19 @@
+import { Layer } from 'effect';
+import { type VcsProvider } from '../vcs';
+import type { CascadeRules, SizePatterns } from './types';
+type RcVersionManagerOptions = {
+    sizes?: SizePatterns;
+    cascade?: CascadeRules;
+    rcIdentifier?: string;
+    upgradeReady?: boolean;
+    tagPrereleases?: boolean;
+};
+export declare const makeRCVersionManager: (vcs: VcsProvider, options?: RcVersionManagerOptions) => import(".").VersionManager;
+export declare const RCVersionManagerLive: (options?: {
+    sizes?: SizePatterns;
+    cascade?: CascadeRules;
+    rcIdentifier?: string;
+    upgradeReady?: boolean;
+    tagPrereleases?: boolean;
+}) => Layer.Layer<import(".").VersionManager, never, VcsProvider>;
+export {};

package/lib-types/versioning/types.d.ts

@@ -0,0 +1,21 @@
+export type PreRelease = {
+    kind: 'pre';
+    size?: string;
+};
+export type BumpSize = 'major' | 'minor' | 'patch' | PreRelease | 'skip';
+export interface PatternConfig {
+    pattern: string;
+}
+export interface SizePatterns {
+    major: PatternConfig;
+    minor: PatternConfig;
+    patch: PatternConfig;
+    skip: PatternConfig;
+}
+export interface CascadeRules {
+    skip?: Record<string, BumpSize>;
+    patch?: Record<string, BumpSize>;
+    minor?: Record<string, BumpSize>;
+    major?: Record<string, BumpSize>;
+    [key: string]: Record<string, BumpSize> | undefined;
+}

package/lib-types/versioning/utils.d.ts

@@ -0,0 +1,3 @@
+import type { BumpSize, SizePatterns } from "./types";
+export declare const matchBumpSize: (message: string, sizes: SizePatterns) => BumpSize;
+export declare const defaultBumpVersion: (version: string, size: BumpSize) => string;

package/lib-types/versioning/vcs-version-manager.d.ts

@@ -0,0 +1,14 @@
+import { Layer } from 'effect';
+import { type VcsProvider } from '../vcs';
+import type { BumpSize, CascadeRules, SizePatterns } from './types';
+export declare const makeVcsVersionManager: (vcs: VcsProvider, options?: {
+    sizes?: SizePatterns;
+    cascade?: CascadeRules;
+    bumpVersionImpl?: (version: string, size: BumpSize) => string;
+    isRCMode?: boolean;
+    tagPrereleases?: boolean;
+}) => import(".").VersionManager;
+export declare const VcsVersionManagerLive: (options?: {
+    sizes?: SizePatterns;
+    cascade?: CascadeRules;
+}) => Layer.Layer<import(".").VersionManager, never, VcsProvider>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relacher",
-  "version": "0.0.4",
+  "version": "0.0.5-rc.0",
   "description": "Scriptable release orchestration library for monorepos",
   "type": "module",
   "private": false,
@@ -60,6 +60,7 @@
   },
   "dependencies": {
     "@decimalturn/toml-patch": "^2.0.0",
+    "effect": "^4.0.0-beta.78",
     "jsonc-parser": "^3.3.1",
     "smol-toml": "^1.6.1",
     "yaml": "^2.9.0"

package/src/index.ts

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