relacher 0.0.6 → 0.0.7-rc.0

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

@@ -1,4 +1,4 @@
 import { type PackageList } from './shared';
 export interface CargoBuilderOptions {
 }
-export declare function loadCargoDeps(cwd: string, options?: CargoBuilderOptions): PackageList;
+export declare function loadCargoDeps(cwd: string, _options?: CargoBuilderOptions): PackageList;

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

@@ -0,0 +1,4 @@
+import type { PackageConfig } from '../types';
+export declare function normalizePosixPath(filePath: string): string;
+export declare function toPosixRelative(fromDir: string, targetPath: string): string;
+export declare function getNestedExcludedPaths(currentPkg: PackageConfig, allPackages: PackageConfig[]): string[];

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

@@ -1,13 +1,4 @@
 import { type PackageList } from './shared';
-/**
- * Loads a single project package configuration from package.json.
- */
 export declare function pnpmProject(cwd: string): PackageList;
-/**
- * Parses pnpm-workspace.yaml to identify target members and versioning topologies.
- */
 export declare function pnpmWorkspace(cwd: string): PackageList;
-/**
- * Auto-detects whether the workspace configuration exists, reverting to single packages.
- */
 export declare function loadPnpmDeps(cwd: string): PackageList;

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

@@ -1,34 +1,46 @@
-import type { PackageConfig } from '../types';
-import type { UpdateAction, VersionFallback } from '../updater';
+import type { ChangelogContext, PackageConfig } from '../types';
+import { type UpdateAction, type VersionFallback } from '../updater';
 export interface PackageListError {
     name: string;
     message: string;
 }
-export interface PackageList extends Array<PackageConfig> {
-    /** Internal array storing any validation/scoping errors */
+export declare class PackageList extends Array<PackageConfig> {
     errors: PackageListError[];
-    /** Merges another list or array of configs into this one, inheriting any errors */
-    append(configs: PackageConfig[]): this;
-    /** Attaches update actions (e.g. file replacements, changelogs) to a specific package */
+    static create(configs?: PackageConfig[]): PackageList;
+    append(newConfigs: PackageConfig[] | PackageList): this;
     onPackageBump(name: string, ...actions: UpdateAction[]): this;
-    /** Attaches update actions to ALL packages currently in the list */
     onAllPackages(...actions: UpdateAction[]): this;
+    group(groupName: string, ...packageNames: string[]): this;
     /**
-     * Couples two packages together so that if one bumps, the other bumps to the exact same version.
-     * Useful for tightly integrated monorepo packages (e.g. core & cli).
+     * Couples two or more packages together so they share the exact same version bump.
+     * Supports: `.couple('a', 'b')` or `.couple(['a', 'b'], ['c', 'd'])`.
      */
-    couple(a: string, b: string): this;
-    /** Validates that the provided packages exist in the current scope */
+    couple(...args: [string, string] | [string[]]): this;
+    /**
+     * Automatically adds a CHANGELOG.md update action to each package's directory.
+     */
+    withChangelogs(options?: {
+        only?: string[];
+        exclude?: string[];
+        template?: (ctx: ChangelogContext) => string;
+    }): this;
+    /**
+     * Attaches a workspace-wide root CHANGELOG.md that captures all changes across packages.
+     */
+    withRootChangelog(options?: {
+        github?: string;
+        path?: string;
+        template?: (ctx: ChangelogContext) => string;
+    }): this;
+    /**
+     * Declaratively syncs a package version to any file on disk (e.g. `flake.nix`, `README.md`).
+     */
+    syncVersion(packageName: string, filePath: string, pattern?: string | RegExp, replaceTemplate?: string): this;
     assertFound(...names: string[]): this;
-    /** Adds dependency linkages, enforcing that the target dependency is already in scope */
     addDepsOn(pkgName: string, dependsOn: string | string[]): this;
-    /** Removes the specified packages from the list entirely */
     ignore(...names: string[]): this;
-    /** Removes ALL packages from the list EXCEPT the specified ones */
     only(...names: string[]): this;
-    /** Adds custom file paths to watch for changes that should trigger a bump for this package */
     addWatchFiles(pkgName: string, paths: string | string[]): this;
-    /** Overrides the fallback strategy used if the package has no previously published tags */
     setVersionFallback(pkgName: string, fallback: VersionFallback): this;
 }
 export declare function createPackageList(configs?: PackageConfig[]): PackageList;

package/lib-types/index.d.ts

@@ -8,3 +8,5 @@ export * from './updater';
 export * from './versioning';
 export * from './lockfile';
 export * from './init';
+export * from './workspace/paths';
+export * from './orchestrator';

package/lib-types/init.d.ts

@@ -1,11 +1,6 @@
 import { Effect } from 'effect';
 import type { PackageConfig } from './types';
 import { type VcsProvider } from './vcs';
-/**
- * Initializes the `.relacher.lock` file if it does not exist.
- * It resolves the version using each package's `versionFallback`,
- * creates the lockfile, and commits it to establish the baseline.
- */
 export declare function init(packages: PackageConfig[], options?: {
     cwd?: string;
 }): Effect.Effect<void, Error, VcsProvider>;

package/lib-types/lockfile.d.ts

@@ -1,10 +1,15 @@
+import { Effect } from 'effect';
 import type { DependencyUpdateReport } from './types';
+import type { VcsError, VcsProvider } from './vcs';
+export interface LockfilePackageEntry {
+    version: string;
+    lastStableVersion?: string;
+}
 export interface LockfileData {
-    packages: Record<string, {
-        version: string;
-        lastStableVersion?: string;
-    }>;
+    packages: Record<string, LockfilePackageEntry>;
 }
+export declare const LOCKFILE_NAME = ".relacher.lock";
 export declare function readLockfile(cwd: string): LockfileData;
 export declare function writeLockfile(cwd: string, data: LockfileData): void;
 export declare function updateLockfile(cwd: string, reports: DependencyUpdateReport[]): void;
+export declare function findLastReleaseCommit(vcs: VcsProvider, packageName: string, currentVersion: string): Effect.Effect<string | null, VcsError>;

package/lib-types/orchestrator.d.ts

@@ -0,0 +1,44 @@
+import { type PackageList } from './builder';
+import type { PreparedUpdate } from './types';
+import { type VcsProvider } from './vcs';
+import { type CascadeRules, type SizePatterns } from './versioning';
+export interface RelacherConfig {
+    /** Project root directory. Defaults to `process.cwd()` */
+    cwd?: string;
+    /** Discovered packages list */
+    packages: PackageList;
+    /** VCS Provider: 'git', 'jj', or custom VcsProvider. Defaults to auto-detection */
+    vcs?: 'git' | 'jj' | VcsProvider;
+    /** Custom RC identifier (default: 'rc') */
+    rcIdentifier?: string;
+    /** Custom Conventional Commit patterns */
+    sizes?: SizePatterns;
+    /** Dependency bump cascade rules */
+    cascade?: CascadeRules;
+    /** Exclude nested watch paths from parent bumps (default: true) */
+    excludeNestedWatches?: boolean;
+    /** Custom commit title callback */
+    commitTitle?: (bumps: Record<string, string>, defaultTitle: string) => string;
+}
+export declare function createRelacher(config: RelacherConfig): {
+    vcs: VcsProvider;
+    /**
+     * Initializes `.relacher.lock` and creates the baseline commit.
+     */
+    init(): Promise<void>;
+    /**
+     * Previews and calculates pending version bumps without writing changes.
+     */
+    prepare(options?: {
+        mode?: "release" | "pre-release";
+    }): Promise<PreparedUpdate>;
+    /**
+     * Writes planned updates to disk and commits via VCS.
+     */
+    run(prepared: PreparedUpdate): Promise<void>;
+    /**
+     * Full interactive CLI entry point.
+     * Handles arguments, preflight logs, confirmation prompts, dry-runs, and execution.
+     */
+    cli(argv?: string[]): Promise<void>;
+};

package/lib-types/prepare.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import type { Commit, PackageConfig, DependencyUpdateReport, IntermediateReport, PrepareOptions, PreparedUpdate } from './types';
+import type { Commit, DependencyUpdateReport, IntermediateReport, PackageConfig, PreparedUpdate, PrepareOptions } from './types';
 import type { UpdateAction, UpdateActionResolved } from './updater';
 import { type VersionManager } from './versioning';
 import type { BumpSize } from './versioning/types';

package/lib-types/run.d.ts

@@ -1,16 +1,9 @@
 import { Effect } from 'effect';
 import type { DependencyUpdateReport, PreparedUpdate } 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[], options?: {
     commitTitle?: (defaultTitle: string, bumps: Record<string, string>) => string;
 }): string | null;
-/**
- * Applies calculated updates to files on disk, stages, commits, and tags using the VcsProvider from context.
- */
 export declare function run(prepared: PreparedUpdate, options: {
     cwd: string;
     commitTitle?: (defaultTitle: string, bumps: Record<string, string>) => string;

package/lib-types/types.d.ts

@@ -19,10 +19,13 @@ export interface ChangelogContext {
 }
 export interface PackageConfig {
     name: string;
+    manifestPath?: string;
     watch?: string[];
     updates: UpdateAction[];
     versionFallback?: VersionFallback;
     depends?: string[];
+    coupled?: string[];
+    group?: string;
 }
 export interface PrepareOptions {
     cwd?: string;
@@ -32,42 +35,34 @@ export interface DependencyError {
     name: string;
     message: string;
 }
-export type PreparedUpdate = {
-    isEmpty: boolean;
-    deps: DependencyUpdateReport[];
-    isDirty?: boolean;
-} & ({
-    isInvalid: true;
-    errors: DependencyError[];
-} | {
-    isInvalid: false;
-});
-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;
-}
-export interface IntermediateReport {
+export interface BaseReport<TUpdates> {
     name: string;
     currentVersion: string;
     newVersion: string;
-    bump: BumpSize;
     lastStableVersion?: string | null;
+    bump: BumpSize;
     originalBump?: BumpSize;
     commits: Commit[];
     commitsSincePreRelease?: Commit[];
-    updates: UpdateAction[];
+    updates: TUpdates;
     depends: string[];
+    coupled?: string[];
+    group?: string;
     isErroneous?: boolean;
     isFirstRelease?: boolean;
 }
+export type IntermediateReport = BaseReport<UpdateAction[]>;
+export interface DependencyUpdateReport extends BaseReport<UpdateActionResolved[]> {
+    skipTag?: boolean;
+}
+export type PreparedUpdate = {
+    isEmpty: boolean;
+    deps: DependencyUpdateReport[];
+    isDirty?: boolean;
+} & ({
+    isInvalid: true;
+    errors: DependencyError[];
+} | {
+    isInvalid: false;
+    errors?: DependencyError[];
+});

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

@@ -4,6 +4,7 @@ export type UpdateActionOptions = {
     newVersion: string;
     globalCommits: Commit[];
     crateCommits: Commit[];
+    commitsSincePreRelease?: Commit[];
 };
 export interface UpdateActionResolved {
     kind: string;
@@ -20,6 +21,7 @@ export interface UpdateAction {
     params: any;
     prepare(data: UpdateActionOptions): UpdateActionResolved;
     skipIf(fn: (cwd: string) => boolean): this;
+    shouldSkip(cwd: string): boolean;
     _skipIf(cwd: string): boolean;
 }
 export interface VersionFallback {

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

@@ -1,7 +1,11 @@
-import { type ChangelogContext } from '../types';
+import type { ChangelogContext } from '../types';
 export type ChangelogUpdateParams = {
     global?: boolean;
     template?: (ctx: ChangelogContext) => string;
 };
 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;
+/**
+ * Built-in Conventional Commits template with GitHub links and scoped categorization.
+ */
+export declare function githubChangelogTemplate(repo: string): ({ version, date, commits }: ChangelogContext) => string;

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

@@ -1,5 +1,5 @@
 import type { DependencyUpdateReport } from '../types';
-import { type VersionFallback } from '.';
+import { type VersionFallback } from './builder';
 export type JsonFallbackParams = {
     path: string;
     read: (parsed: any) => string | null | undefined;

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

@@ -0,0 +1,4 @@
+/**
+ * Shared recursive Proxy generator tracking modified property paths on target objects.
+ */
+export declare function createMutationProxy(obj: any, currentPath: string[] | undefined, onSet: (path: string[], value: any) => void): any;

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

@@ -1,5 +1,5 @@
 import type { DependencyUpdateReport } from '../types';
-import { type VersionFallback } from '.';
+import { type VersionFallback } from './builder';
 export type YamlFallbackParams = {
     path: string;
     read: (parsed: any) => string | null | undefined;

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

@@ -0,0 +1,3 @@
+import type { Commit } from '../types';
+export declare function parseCommit(hash: string, author: string, date: string, message: string): Commit;
+export declare function parseCommitLine(line: string): Commit | null;

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

@@ -0,0 +1,9 @@
+export declare function isInsideGitWorkTree(cwd: string): boolean;
+export declare function isGitTracked(filePath: string, cwd: string): boolean;
+export declare function isInsideJjWorkTree(cwd: string): boolean;
+export declare function isJjTracked(filePath: string, cwd: string): boolean;
+/**
+ * Centrally verifies if a given path is tracked by VCS without shell interpolation.
+ * If the workspace is not inside any VCS repository, defaults to true.
+ */
+export declare function isPathTrackedSync(absolutePath: string, workspaceRoot: string): boolean;

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

@@ -1,10 +1,9 @@
 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 getGitCommits(name: string, watch: string[], lastCommit: string | null, cwd: string, exclude?: string[]): Effect.Effect<Commit[], never>;
-export declare function getGitHeadCommit(cwd: string): Effect.Effect<string, never>;
-export declare function findGitLastReleaseCommit(packageName: string, currentVersion: string, cwd: string): Effect.Effect<string | null, never>;
-export declare function isGitDirty(cwd: string): Effect.Effect<boolean, never>;
+import { VcsError, type VcsProvider } from './index';
+export declare function runGit(cmdOrArgs: string | string[], cwd: string): Effect.Effect<string, VcsError>;
+export declare function isGitTrackedSync(filePath: string, cwd: string): boolean;
+export declare function parseGitLogOutput(output: string): Commit[];
+export declare function getGitCommits(watch: string[], lastCommit: string | null, cwd: string, exclude?: string[]): Effect.Effect<Commit[], VcsError>;
 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,12 +1,25 @@
 import { Context, type Effect } from 'effect';
 import type { Commit } from '../types';
+declare const VcsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "VcsError";
+} & Readonly<A>;
+export declare class VcsError extends VcsError_base<{
+    readonly message: string;
+    readonly command?: string;
+    readonly cause?: unknown;
+}> {
+}
 export interface VcsProvider {
-    readonly getCommits: (name: string, watch: string[], lastCommit: string | null, exclude?: string[]) => Effect.Effect<Commit[], Error>;
-    readonly getHeadCommit: () => Effect.Effect<string, Error>;
-    readonly findLastReleaseCommit: (packageName: string, currentVersion: string) => Effect.Effect<string | null, Error>;
-    readonly commit: (message: string) => Effect.Effect<void, Error>;
-    readonly isDirty: () => Effect.Effect<boolean, Error>;
+    readonly getCommits: (watch: string[], lastCommit: string | null, exclude?: string[]) => Effect.Effect<Commit[], VcsError>;
+    readonly getHeadCommit: () => Effect.Effect<string, VcsError>;
+    readonly commit: (message: string) => Effect.Effect<void, VcsError>;
+    readonly isDirty: () => Effect.Effect<boolean, VcsError>;
+    readonly findLastReleaseCommit?: (packageName: string, currentVersion: string) => Effect.Effect<string | null, VcsError>;
+    readonly getFileAtCommit?: (filePath: string, commitHash: string) => Effect.Effect<string | null, VcsError>;
+    readonly getFileHistoryCommits?: (filePath: string) => Effect.Effect<string[], VcsError>;
+    readonly isTracked?: (filePath: string) => Effect.Effect<boolean, VcsError>;
 }
 export declare const VcsProviderService: Context.Service<VcsProvider, VcsProvider>;
 export * from './git';
 export * from './jj';
+export * from './common';

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

@@ -1,12 +1,8 @@
 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 getJjCommits(name: string, watch: string[], lastCommit: string | null, cwd: string, exclude?: string[]): Effect.Effect<Commit[], never>;
-export declare function getJjHeadCommit(cwd: string): Effect.Effect<string, never>;
-export declare function findJjLastReleaseCommit(packageName: string, currentVersion: string, cwd: string): Effect.Effect<string | null, never>;
-export declare function isJjDirty(cwd: string): Effect.Effect<boolean, never>;
+import { VcsError, type VcsProvider } from './index';
+export declare function runJj(cmdOrArgs: string | string[], cwd: string): Effect.Effect<string, VcsError>;
+export declare function isJjTrackedSync(filePath: string, cwd: string): boolean;
+export declare function getJjCommits(watch: string[], lastCommit: string | null, cwd: string, exclude?: string[]): Effect.Effect<Commit[], VcsError>;
 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

@@ -1,21 +1,5 @@
-import { Context, Effect } from 'effect';
-import type { Commit, PackageConfig, IntermediateReport } from '../types';
-import type { BumpSize } from './types';
-export interface VersionManager {
-    readonly isRCMode: boolean;
-    readonly tagPrereleases: boolean;
-    readonly getCurrentVersion: (dep: PackageConfig, cwd: string) => Effect.Effect<{
-        version: string | null;
-        isFallback: boolean;
-        lastStableVersion?: string | null;
-    }, Error>;
-    readonly getCommits: (dep: PackageConfig, excludePaths: string[], cwd: 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 './types';
+export * from './utils';
+export * from './default-data';
 export * from './vcs-version-manager';
 export * from './rc-version-manager';

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

@@ -1,19 +1,12 @@
 import { Layer } from 'effect';
 import { type VcsProvider } from '../vcs';
 import type { CascadeRules, SizePatterns } from './types';
-type RcVersionManagerOptions = {
+export interface 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 {};
+}
+export declare const makeRCVersionManager: (vcs: VcsProvider, options?: RcVersionManagerOptions) => import("./vcs-version-manager").VersionManager;
+export declare const RCVersionManagerLive: (options?: RcVersionManagerOptions) => Layer.Layer<import("./vcs-version-manager").VersionManager, never, VcsProvider>;

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

@@ -0,0 +1,13 @@
+export interface ParsedSemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: string;
+    prereleaseId?: string;
+    prereleaseNum?: number;
+}
+export declare function parseSemVer(version: string): ParsedSemVer | null;
+export declare function formatSemVer(semver: ParsedSemVer): string;
+export declare function isVersionGreater(v1: string, v2: string): boolean;
+export declare function bumpStableVersion(version: string, size: 'major' | 'minor' | 'patch'): string;
+export declare function inferLastStableVersion(version: string): string;

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

@@ -1,3 +1,5 @@
-import type { BumpSize, SizePatterns } from "./types";
+import { inferLastStableVersion, isVersionGreater, parseSemVer } from './semver';
+import type { BumpSize, SizePatterns } from './types';
+export { inferLastStableVersion, isVersionGreater, parseSemVer };
 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

@@ -1,14 +1,32 @@
-import { Layer } from 'effect';
+import { Context, Effect, Layer } from 'effect';
+import { type LockfileData } from '../lockfile';
+import type { Commit, IntermediateReport, PackageConfig } from '../types';
 import { type VcsProvider } from '../vcs';
 import type { BumpSize, CascadeRules, SizePatterns } from './types';
+export interface VersionManager {
+    readonly isRCMode: boolean;
+    readonly tagPrereleases: boolean;
+    readonly getCurrentVersion: (dep: PackageConfig, cachedLockfile: LockfileData, cwd: string) => {
+        version: string | null;
+        isFallback: boolean;
+        lastStableVersion?: string | null;
+    };
+    readonly getCommits: (dep: PackageConfig, cachedLockfile: LockfileData, excludePaths: string[], cwd: 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 declare const makeVcsVersionManager: (vcs: VcsProvider, options?: {
     sizes?: SizePatterns;
     cascade?: CascadeRules;
     bumpVersionImpl?: (version: string, size: BumpSize) => string;
     isRCMode?: boolean;
     tagPrereleases?: boolean;
-}) => import(".").VersionManager;
+}) => VersionManager;
 export declare const VcsVersionManagerLive: (options?: {
     sizes?: SizePatterns;
     cascade?: CascadeRules;
-}) => Layer.Layer<import(".").VersionManager, never, VcsProvider>;
+}) => Layer.Layer<VersionManager, never, VcsProvider>;

package/lib-types/workspace/paths.d.ts

@@ -0,0 +1,4 @@
+import type { PackageConfig } from '../types';
+export declare function normalizePosixPath(filePath: string): string;
+export declare function toPosixRelative(fromDir: string, targetPath: string): string;
+export declare function getNestedExcludedPaths(currentPkg: PackageConfig, allPackages: PackageConfig[]): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relacher",
-  "version": "0.0.6",
+  "version": "0.0.7-rc.0",
   "description": "Scriptable release orchestration library for monorepos",
   "type": "module",
   "private": false,
@@ -43,12 +43,12 @@
     "LICENSE"
   ],
   "scripts": {
-    "ts:build": "tsc -p tsconfig.build.json",
-    "ts:watch": "tsc --noEmit --incremental --preserveWatchOutput --pretty --watch",
+    "ts.build": "tsc -p tsconfig.build.json",
+    "ts.watch": "tsc --noEmit --incremental --preserveWatchOutput --pretty --watch",
     "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "lint:watch": "oxlint --watch",
-    "prepublishOnly": "bun run ts:build"
+    "lint.fix": "oxlint --fix",
+    "lint.watch": "oxlint --watch",
+    "prepublishOnly": "bun run ts.build"
   },
   "devDependencies": {
     "@types/bun": "latest",