relacher 0.0.5-rc.7 → 0.0.5

package/lib-types/index.d.ts

@@ -7,3 +7,4 @@ export * from './types';
 export * from './updater';
 export * from './versioning';
 export * from './lockfile';
+export * from './init';

package/lib-types/init.d.ts

@@ -0,0 +1,11 @@
+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/types.d.ts

@@ -35,6 +35,7 @@ export interface DependencyError {
 export type PreparedUpdate = {
     isEmpty: boolean;
     deps: DependencyUpdateReport[];
+    isDirty?: boolean;
 } & ({
     isInvalid: true;
     errors: DependencyError[];

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

@@ -5,5 +5,6 @@ export declare function runGit(cmd: string, cwd: string): Effect.Effect<string,
 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>;
 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,10 +1,11 @@
-import { Context, Effect } from 'effect';
+import { Context, type Effect } from 'effect';
 import type { Commit } from '../types';
 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>;
 }
 export declare const VcsProviderService: Context.Service<VcsProvider, VcsProvider>;
 export * from './git';

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

@@ -7,5 +7,6 @@ export declare function runJj(cmd: string, cwd: string, opts?: {
 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>;
 export declare function makeJjVcsProvider(cwd: string): VcsProvider;
 export declare const JjVcsProviderLive: (cwd: string) => Layer.Layer<VcsProvider, never, never>;

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

@@ -1,3 +1,3 @@
 import type { CascadeRules, SizePatterns } from './types';
 export declare const defaultSizes: SizePatterns;
-export declare const defaultCascadeRules: Required<CascadeRules>;
+export declare const defaultCascadeRules: CascadeRules;

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

@@ -12,10 +12,4 @@ export interface SizePatterns {
     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;
-}
+export type CascadeRules = Record<string, BumpSize>;

package/package.json

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

package/src/display/print.ts

@@ -1,6 +1,8 @@
 import { pipe } from 'effect';
 
 import type { PreparedUpdate } from '../types';
+import { defaultSizes } from '../versioning/default-data';
+import { matchBumpSize } from '../versioning/utils';
 
 import { getIconForFile } from './devicons';
 import { c, log } from './utils';
@@ -75,6 +77,10 @@ function getVersionDisplay(oldV: string, newV: string, lastStableVersion?: strin
 }
 
 export function prettyPrint(prepared: PreparedUpdate): void {
+  if (prepared.isDirty) {
+    log.warn('The repository has unstaged or uncommitted changes (dirty status).');
+  }
+
   if (prepared.isInvalid) {
     console.log(c.red('\nErrors detected during preparation:'));
     for (const err of prepared.errors) {
@@ -116,7 +122,7 @@ export function prettyPrint(prepared: PreparedUpdate): void {
 
     // 1. Show all commits since the last release with a bump marker if applicable
     for (const commit of report.commits) {
-      const commitBump = 'skip'; //matchBumpSize(commit.message, defaultSizes);
+      const commitBump = matchBumpSize(commit.message, defaultSizes);
       const affectsBump = commitBump !== 'skip';
 
       const marker = affectsBump ? `${c.green('✦')}` : `${c.gray('○')}`;

package/src/index.ts

@@ -7,3 +7,4 @@ export * from './types';
 export * from './updater';
 export * from './versioning';
 export * from './lockfile';
+export * from './init';

package/src/init.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { Effect } from 'effect';
+
+import { log } from './display';
+import { writeLockfile, type LockfileData } from './lockfile';
+import type { PackageConfig } from './types';
+import { VcsProviderService, 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 function init(
+  packages: PackageConfig[],
+  options: { cwd?: string } = {},
+): Effect.Effect<void, Error, VcsProvider> {
+  return Effect.gen(function*() {
+    const cwd = options.cwd || process.cwd();
+    const lockPath = path.resolve(cwd, '.relacher.lock');
+
+    if (fs.existsSync(lockPath)) {
+      return;
+    }
+
+    const vcs = yield* VcsProviderService;
+
+    // Check for dirty repository status
+    const isDirty = yield* vcs.isDirty();
+    if (isDirty) {
+      return yield* Effect.fail(
+        new Error('Cannot initialize lockfile: repository has dirty status.'),
+      );
+    }
+
+    const lockfile: LockfileData = { packages: {} };
+
+    let warn_flag = false;
+    for (const pkg of packages) {
+      let version = '0.0.0';
+      if (pkg.versionFallback) {
+        try {
+          const fallback = pkg.versionFallback.readFallback(cwd);
+          if (fallback) {
+            version = fallback;
+          }
+        } catch (_) {
+          log.warn(`Version fallback failed for package ${pkg.name}`);
+          warn_flag = true;
+          // Fall back to default version if reading fails
+        }
+      }
+
+      const isPrerelease = version.includes('-');
+      lockfile.packages[pkg.name] = {
+        version,
+        lastStableVersion: isPrerelease ? undefined : version,
+      };
+    }
+
+    if (warn_flag) {
+      log.warn(
+        'One or more package failed to retrieve their version, update .relacher.lockfile manually.',
+      );
+    }
+
+    writeLockfile(cwd, lockfile);
+
+    const commitMessage = `chore: initialize .relacher.lock\n\nInitialized package versions from workspace fallbacks.`;
+    yield* vcs.commit(commitMessage);
+  }) as Effect.Effect<void, Error, VcsProvider>;
+}

package/src/prepare.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { Effect } from 'effect';
+import { Effect, Option } from 'effect';
 
 import type {
   Commit,
@@ -13,6 +13,7 @@ import type {
   DependencyError,
 } from './types';
 import type { UpdateAction, UpdateActionResolved } from './updater';
+import { VcsProviderService } from './vcs';
 import { VersionManagerService, type VersionManager } from './versioning';
 import type { BumpSize } from './versioning/types';
 
@@ -190,10 +191,14 @@ export function prepare(
           name: err.name,
           message: err.message,
         })) as DependencyError[],
+        isDirty: false,
       };
     }
 
     const versionManager = yield* VersionManagerService;
+    const vcsOption = yield* Effect.serviceOption(VcsProviderService);
+    const isDirty = Option.isSome(vcsOption) ? yield* vcsOption.value.isDirty() : false;
+
     const cwd = options.cwd || process.cwd();
 
     const items = yield* initReportItems(packages, cwd, options.excludeNestedWatches);
@@ -215,6 +220,7 @@ export function prepare(
           name: r.name,
           message: `Package ${r.name} is missing a version or a required update file.`,
         })) as DependencyError[],
+        isDirty,
       };
     }
 
@@ -222,6 +228,7 @@ export function prepare(
       isEmpty,
       deps,
       isInvalid: false,
+      isDirty,
     };
   }) as Effect.Effect<PreparedUpdate, Error, VersionManager>;
 }

package/src/run.ts

@@ -56,6 +56,12 @@ export function run(
   return Effect.gen(function*() {
     const vcs = yield* VcsProviderService;
 
+    // Check for dirty repository status
+    const isDirty = yield* vcs.isDirty();
+    if (isDirty) {
+      return yield* Effect.fail(new Error('Cannot run release: repository has dirty status.'));
+    }
+
     // Reject run early if preparation is flagged as invalid
     if (prepared.isInvalid) {
       const messages = prepared.errors

package/src/types.ts

@@ -41,10 +41,8 @@ export interface DependencyError {
 export type PreparedUpdate = {
   isEmpty: boolean;
   deps: DependencyUpdateReport[];
-} & (
-  | { isInvalid: true; errors: DependencyError[] }
-  | { isInvalid: false }
-);
+  isDirty?: boolean;
+} & ({ isInvalid: true; errors: DependencyError[] } | { isInvalid: false });
 
 export interface DependencyUpdateReport {
   name: string;

package/src/vcs/git.ts

@@ -115,6 +115,12 @@ export function findGitLastReleaseCommit(
   );
 }
 
+export function isGitDirty(cwd: string): Effect.Effect<boolean, never> {
+  return runGit('git diff --name-only', cwd).pipe(
+    Effect.map((output) => output.trim().length > 0),
+  );
+}
+
 // Service Factory Implementation
 export function makeGitVcsProvider(cwd: string): VcsProvider {
   return VcsProviderService.of({
@@ -131,6 +137,8 @@ export function makeGitVcsProvider(cwd: string): VcsProvider {
         Effect.flatMap(() => runGit(`git commit -m "${message}"`, cwd)),
         Effect.asVoid,
       ),
+
+    isDirty: () => isGitDirty(cwd),
   });
 }
 

package/src/vcs/index.ts

@@ -1,4 +1,4 @@
-import { Context, Effect } from 'effect';
+import { Context, type Effect } from 'effect';
 
 import type { Commit } from '../types';
 
@@ -18,6 +18,8 @@ export interface VcsProvider {
   ) => Effect.Effect<string | null, Error>;
 
   readonly commit: (message: string) => Effect.Effect<void, Error>;
+
+  readonly isDirty: () => Effect.Effect<boolean, Error>;
 }
 
 export const VcsProviderService = Context.Service<VcsProvider>('VcsProviderService');

package/src/vcs/jj.ts

@@ -93,7 +93,6 @@ export function findJjLastReleaseCommit(
   currentVersion: string,
   cwd: string,
 ): Effect.Effect<string | null, never> {
-  // Query only commits modifying the lockfile using highly-compatible path filtering
   return runJj('log --no-graph -T \'commit_id ++ "\\n"\' -- .relacher.lock', cwd).pipe(
     Effect.map((output) => {
       const hashes = output
@@ -106,7 +105,6 @@ export function findJjLastReleaseCommit(
 
       for (const hash of hashes) {
         try {
-          // Attempt the retrieval, catching any command or JSON-parsing errors
           const content = execSync(`jj file show .relacher.lock -r ${hash}`, {
             cwd,
             encoding: 'utf8',
@@ -131,6 +129,30 @@ export function findJjLastReleaseCommit(
   );
 }
 
+export function isJjDirty(cwd: string): Effect.Effect<boolean, never> {
+  return Effect.gen(function*() {
+    // 1. Check if current commit @ is not empty
+    const currentStatus = yield* runJj(
+      'log --no-graph -r @ -T \'if(empty, "empty", "not-empty")\'',
+      cwd,
+    );
+    if (currentStatus.trim() === 'not-empty') {
+      return true;
+    }
+
+    // 2. Check if there are any commits without a description in the history (excluding root and the current commit)
+    const historyDescriptions = yield* runJj(
+      'log --no-graph -r "::@ & ~@ & ~root()" -T \'if(description, "1", "0")\'',
+      cwd,
+    );
+    if (historyDescriptions.includes('0')) {
+      return true;
+    }
+
+    return false;
+  });
+}
+
 // Service Factory Implementation
 export function makeJjVcsProvider(cwd: string): VcsProvider {
   return VcsProviderService.of({
@@ -143,6 +165,8 @@ export function makeJjVcsProvider(cwd: string): VcsProvider {
       findJjLastReleaseCommit(packageName, currentVersion, cwd),
 
     commit: (message) => runJj(`commit -m "${message}"`, cwd).pipe(Effect.asVoid),
+
+    isDirty: () => isJjDirty(cwd),
   });
 }
 

package/src/versioning/default-data.ts

@@ -7,9 +7,9 @@ export const defaultSizes: SizePatterns = {
   skip: { pattern: '^release|^chore|^infra|^docs|^test|^ci|^build' },
 };
 
-export const defaultCascadeRules: Required<CascadeRules> = {
-  skip: { skip: 'skip', patch: 'patch', minor: 'patch', major: 'patch' },
-  patch: { skip: 'patch', patch: 'patch', minor: 'minor', major: 'minor' },
-  minor: { skip: 'minor', patch: 'minor', minor: 'minor', major: 'minor' },
-  major: { skip: 'major', patch: 'major', minor: 'major', major: 'major' },
+export const defaultCascadeRules: CascadeRules = {
+  skip: 'skip',
+  patch: 'patch',
+  minor: 'patch',
+  major: 'minor',
 };

package/src/versioning/types.ts

@@ -12,10 +12,4 @@ export interface SizePatterns {
   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;
-}
+export type CascadeRules = Record<string, BumpSize>;

package/src/versioning/vcs-version-manager.ts

@@ -47,28 +47,6 @@ const getBumpSizeByPriority = (priorityValue: number, originalBump: BumpSize): B
   return 'skip';
 };
 
-const getCascadeRule = (
-  original: BumpSize,
-  dependencyBump: BumpSize,
-  activeRules: Record<string, Record<string, BumpSize> | undefined>,
-): BumpSize | undefined => {
-  const origKey =
-    typeof original === 'string' ? original : original.size ? `pre-${original.size}` : 'pre';
-  const depKey =
-    typeof dependencyBump === 'string'
-      ? dependencyBump
-      : dependencyBump.size
-        ? `pre-${dependencyBump.size}`
-        : 'pre';
-
-  const rule = activeRules[origKey]?.[depKey];
-  if (rule !== undefined) return rule;
-
-  const fallBackOrigKey = typeof original === 'string' ? original : 'patch';
-  const fallBackDepKey = typeof dependencyBump === 'string' ? dependencyBump : 'patch';
-  return activeRules[fallBackOrigKey]?.[fallBackDepKey];
-};
-
 const isVersionGreater = (v1: string, v2: string): boolean => {
   const parts1 = v1.replace(/^v/, '').split('.').map(Number);
   const parts2 = v2.replace(/^v/, '').split('.').map(Number);
@@ -175,28 +153,59 @@ export const makeVcsVersionManager = (
     },
 
     propagateBumps: (sorted) => {
-      const activeRules: Record<string, Record<string, BumpSize> | undefined> = {
-        skip: { ...defaultCascadeRules.skip, ...cascadeRules.skip },
-        patch: { ...defaultCascadeRules.patch, ...cascadeRules.patch },
-        minor: { ...defaultCascadeRules.minor, ...cascadeRules.minor },
-        major: { ...defaultCascadeRules.major, ...cascadeRules.major },
+      const activeRules: Record<string, BumpSize> = {
+        patch: 'patch',
+        minor: 'patch',
+        major: 'patch',
+      };
+
+      // Helper to merge cascade rules from both flat and legacy nested structures defensively
+      const mergeRules = (rules: any) => {
+        if (!rules) return;
+        for (const [key, val] of Object.entries(rules)) {
+          if (typeof val === 'string') {
+            activeRules[key] = val as BumpSize;
+          } else if (val && typeof val === 'object') {
+            for (const [subKey, subVal] of Object.entries(val)) {
+              if (typeof subVal === 'string') {
+                activeRules[subKey] = subVal as BumpSize;
+              }
+            }
+          }
+        }
       };
 
+      mergeRules(defaultCascadeRules);
+      mergeRules(cascadeRules);
+
       for (const item of sorted) {
-        let maxDepBump: BumpSize = 'skip';
+        let maxCascadedBump: BumpSize = 'skip';
+
         for (const depName of item.depends) {
           const depItem = sorted.find((r) => r.name === depName);
-          if (depItem) {
-            if (getBumpPriority(depItem.bump) > getBumpPriority(maxDepBump)) {
-              maxDepBump = depItem.bump;
+          if (depItem && depItem.bump !== 'skip') {
+            const depBumpKey =
+              typeof depItem.bump === 'string'
+                ? depItem.bump
+                : depItem.bump.kind === 'pre'
+                  ? depItem.bump.size
+                    ? `pre-${depItem.bump.size}`
+                    : 'pre'
+                  : 'patch';
+
+            const cascadedResult = activeRules[depBumpKey];
+            if (
+              cascadedResult &&
+              getBumpPriority(cascadedResult) > getBumpPriority(maxCascadedBump)
+            ) {
+              maxCascadedBump = cascadedResult;
             }
           }
         }
 
-        if (getBumpPriority(maxDepBump) > 0) {
-          const original = item.bump;
-          const targetBump = getCascadeRule(original, maxDepBump, activeRules) ?? original;
-          item.bump = targetBump;
+        // Apply the cascaded bump only if its priority exceeds the package's existing bump
+        if (getBumpPriority(maxCascadedBump) > getBumpPriority(item.bump)) {
+          item.bump = maxCascadedBump;
         }
 
         item.newVersion =