relacher 0.0.1 → 0.0.3

package/src/types.ts

@@ -1,17 +1,18 @@
+import type { UpdateAction, UpdateActionResolved, VersionFallback } from './updater';
 import type { VcsProvider } from './vcs';
 
-export type BumpSize = "major" | "minor" | "patch" | "skip";
+export type BumpSize = 'major' | 'minor' | 'patch' | 'skip';
 
 export interface Commit {
   hash: string;
   shortHash: string;
   author: string;
   date: string;
-  message: string;          // The full commit message
-  type: string;             // e.g., 'feat', 'fix', 'chore'
-  scope: string | null;     // e.g., 'ui', 'api'
-  isBreaking: boolean;      // true if contains '!' or 'BREAKING CHANGE'
-  description: string;      // The text after the colon
+  message: string; // The full commit message
+  type: string; // e.g., 'feat', 'fix', 'chore'
+  scope: string | null; // e.g., 'ui', 'api'
+  isBreaking: boolean; // true if contains '!' or 'BREAKING CHANGE'
+  description: string; // The text after the colon
 }
 
 export interface ChangelogContext {
@@ -20,34 +21,11 @@ export interface ChangelogContext {
   commits: Commit[];
 }
 
-export interface ChangelogUpdate {
-  kind: "changelog";
-  path: string;
-  global?: boolean;
-  template?: (ctx: ChangelogContext) => string;
-  resolvedBlock?: string;
-}
-
-export interface TomlUpdate {
-  kind: "toml";
-  path: string;
-  toml: string;
-}
-
-export interface RegexUpdate {
-  kind: "regex";
-  path: string;
-  search: string;
-  replace: string;
-  resolvedReplace?: string;
-}
-
-export type UpdateAction = TomlUpdate | RegexUpdate | ChangelogUpdate;
-
 export interface DependencyConfig {
   name: string;
   watch?: string[];
-  updates?: UpdateAction[];
+  updates: UpdateAction[];
+  versionFallback?: VersionFallback;
   depends?: string[];
 }
 
@@ -82,8 +60,10 @@ export interface DependencyUpdateReport {
   bump: BumpSize;
   originalBump?: BumpSize;
   commits: Commit[];
-  updates: UpdateAction[];
+  updates: UpdateActionResolved[];
   depends?: string[];
+  isErroneous?: boolean;
+  isFirstRelease?: boolean;
 }
 
 export interface IntermediateReport {
@@ -95,20 +75,8 @@ export interface IntermediateReport {
   commits: Commit[];
   updates: UpdateAction[];
   depends: string[];
+  isErroneous?: boolean;
+  isFirstRelease?: boolean;
 }
 
-export const defaultSizes: SizePatterns = {
-  major: { pattern: "^[a-z]+(?:\\([^)]+\\))?!:|BREAKING CHANGE" },
-  minor: { pattern: "^feat|^revert" },
-  patch: { pattern: "^fix|^build|^refactor|^nit|^style" },
-  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 type { VcsProvider };

package/src/updater/changelog.ts

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { ChangelogContext } from '../types';
+
+import type { UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+
+export type ChangelogUpdateParams = {
+  path: string;
+  global?: boolean;
+  template?: (ctx: ChangelogContext) => string;
+  required?: boolean;
+};
+
+export const changelogUpdate = (params: ChangelogUpdateParams): UpdateAction => ({
+  kind: 'changelog',
+  path: params.path,
+  required: params.required,
+  params,
+  prepare(data: UpdateActionOptions): UpdateActionResolved {
+    const targetCommits = params.global ? data.globalCommits : data.crateCommits;
+    const context: ChangelogContext = {
+      version: data.newVersion,
+      date: new Date().toISOString().split('T')[0] ?? '',
+      commits: targetCommits,
+    };
+
+    const resolvedBlock = params.template
+      ? params.template(context)
+      : defaultChangelogTemplate(context);
+
+    const t = {
+      kind: 'changelog',
+      path: params.path,
+      params: {
+        ...params,
+        resolvedBlock,
+      },
+      apply(_report, _reports, cwd) {
+        const filePath = path.resolve(cwd, params.path);
+        const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+        const newContent = (resolvedBlock ?? '') + '\n' + oldContent;
+        fs.writeFileSync(filePath, newContent.trim() + '\n');
+      },
+    } satisfies UpdateActionResolved;
+
+    return t;
+  },
+});
+
+export function defaultChangelogTemplate({ version, date, commits }: ChangelogContext): string {
+  let block = `## [${version}] - ${date}\n\n`;
+  if (commits.length === 0) return block + `*No notable changes.*\n`;
+
+  const groups: { breaking: string[]; feat: string[]; fix: string[]; other: string[] } = {
+    breaking: [],
+    feat: [],
+    fix: [],
+    other: [],
+  };
+
+  for (const c of commits) {
+    const item = `- ${c.shortHash} ${c.message}`;
+    if (c.isBreaking) groups.breaking.push(item);
+    else if (c.type === 'feat') groups.feat.push(item);
+    else if (c.type === 'fix') groups.fix.push(item);
+    else groups.other.push(item);
+  }
+
+  if (groups.breaking.length) block += `### ⚠️ BREAKING CHANGES\n${groups.breaking.join('\n')}\n\n`;
+  if (groups.feat.length) block += `### ✨ Features\n${groups.feat.join('\n')}\n\n`;
+  if (groups.fix.length) block += `### 🐛 Bug Fixes\n${groups.fix.join('\n')}\n\n`;
+  if (groups.other.length) block += `### 🛠 Other Changes\n${groups.other.join('\n')}\n\n`;
+
+  return block.trim() + '\n';
+}

package/src/updater/index.ts

@@ -0,0 +1,31 @@
+import type { Commit, DependencyUpdateReport } from '../types';
+
+export * from './changelog';
+export * from './json';
+export * from './regex';
+export * from './toml';
+
+export type UpdateActionOptions = {
+  newVersion: string;
+  globalCommits: Commit[];
+  crateCommits: Commit[];
+};
+
+export interface UpdateActionResolved {
+  kind: string;
+  path: string;
+  apply(report: DependencyUpdateReport, reports: DependencyUpdateReport[], cwd: string): void;
+  params: any;
+}
+
+export interface UpdateAction {
+  kind: string;
+  path: string;
+  required?: boolean;
+  params: any;
+  prepare(data: UpdateActionOptions): UpdateActionResolved;
+}
+
+export interface VersionFallback {
+  readFallback(cwd: string): string | null;
+}

package/src/updater/json.ts

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { VersionFallback, UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+
+export type JsonFallbackParams = { path: string; json: string };
+export type JsonUpdateParams = { path: string; json: string; required?: boolean };
+
+export const jsonFallback = (params: JsonFallbackParams): VersionFallback => ({
+  readFallback(cwd: string): string | null {
+    const filePath = path.resolve(cwd, params.path);
+    if (!fs.existsSync(filePath)) return null;
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      const keys = params.json.split('.');
+      let val: any = data;
+      for (const k of keys) {
+        if (val == null) return null;
+        val = val[k];
+      }
+      return typeof val === 'string' ? val : null;
+    } catch {
+      return null;
+    }
+  },
+});
+
+export const jsonUpdate = (params: JsonUpdateParams): UpdateAction => ({
+  kind: 'json',
+  path: params.path,
+  required: params.required,
+  params,
+  prepare(_data: UpdateActionOptions): UpdateActionResolved {
+    return {
+      kind: 'json',
+      path: params.path,
+      params,
+      apply(report, reports, cwd) {
+        const filePath = path.resolve(cwd, params.path);
+        if (!fs.existsSync(filePath)) return;
+
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        // Detect indent size
+        const indentMatch = content.match(/^[ \t]+/m);
+        const indent = indentMatch ? indentMatch[0] : 2;
+
+        let data: Record<string, any>;
+        try {
+          data = JSON.parse(content);
+        } catch (err) {
+          console.error(`Failed to parse JSON file at ${filePath}`);
+          return;
+        }
+
+        // Update specific JSON path
+        const keys = params.json.split('.');
+        const lastKey = keys.pop();
+        if (lastKey) {
+          let target = data;
+          for (const k of keys) {
+            if (target[k] == null || typeof target[k] !== 'object') {
+              target[k] = {};
+            }
+            target = target[k];
+          }
+          target[lastKey] = report.newVersion;
+        }
+
+        // Sync internal workspace dependency entries
+        const depSections = [
+          'dependencies',
+          'devDependencies',
+          'peerDependencies',
+          'optionalDependencies',
+        ];
+
+        for (const depReport of reports) {
+          if (depReport.name === report.name) continue;
+
+          for (const section of depSections) {
+            if (data[section] && data[section][depReport.name]) {
+              const currentVal = data[section][depReport.name] as string;
+              const prefixMatch = currentVal.match(/^([~^]?)(.*)$/);
+              const prefix = prefixMatch ? prefixMatch[1] : '';
+              data[section][depReport.name] = `${prefix}${depReport.newVersion}`;
+            }
+          }
+        }
+
+        fs.writeFileSync(filePath, JSON.stringify(data, null, indent) + '\n');
+      },
+    };
+  },
+});

package/src/updater/regex.ts

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { VersionFallback, UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+
+export type RegexFallbackParams = { path: string; search: string };
+export type RegexUpdateParams = {
+  path: string;
+  search: string;
+  replace: string;
+  required?: boolean;
+};
+
+export const regexFallback = (params: RegexFallbackParams): VersionFallback => ({
+  readFallback(cwd: string): string | null {
+    const filePath = path.resolve(cwd, params.path);
+    if (!fs.existsSync(filePath)) return null;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const searchRegex = new RegExp(params.search, 'm');
+    const match = content.match(searchRegex);
+    return match && match[1] ? match[1] : null;
+  },
+});
+
+export const regexUpdate = (params: RegexUpdateParams): UpdateAction => ({
+  kind: 'regex',
+  path: params.path,
+  required: params.required,
+  params,
+  prepare(data: UpdateActionOptions): UpdateActionResolved {
+    const resolvedReplace = params.replace.replace('{{version}}', data.newVersion);
+
+    return {
+      kind: 'regex',
+      path: params.path,
+      params: { ...params, resolvedReplace },
+      apply(_report, _reports, cwd) {
+        const filePath = path.resolve(cwd, params.path);
+        if (!fs.existsSync(filePath)) return;
+
+        let content = fs.readFileSync(filePath, 'utf8');
+        const searchRegex = new RegExp(params.search, 'g');
+        content = content.replace(searchRegex, resolvedReplace);
+        fs.writeFileSync(filePath, content);
+      },
+    };
+  },
+});

package/src/updater/toml.ts

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { VersionFallback, UpdateAction, UpdateActionResolved, UpdateActionOptions } from '.';
+
+export type TomlFallbackParams = { path: string; toml: string };
+export type TomlUpdateParams = { path: string; toml: string; required?: boolean };
+
+export const tomlFallback = (params: TomlFallbackParams): VersionFallback => ({
+  readFallback(cwd: string): string | null {
+    const filePath = path.resolve(cwd, params.path);
+    if (!fs.existsSync(filePath)) return null;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const packageMatch = content.match(/\[package\][^]*?(?=^\[|z)/);
+    const targetText = packageMatch ? packageMatch[0] : content;
+    const versionMatch = targetText.match(/^version\s*=\s*"([^"]+)"/m);
+    return versionMatch && versionMatch[1] ? versionMatch[1] : null;
+  },
+});
+
+export const tomlUpdate = (params: TomlUpdateParams): UpdateAction => ({
+  kind: 'toml',
+  path: params.path,
+  params,
+  required: params.required,
+  prepare(_data: UpdateActionOptions): UpdateActionResolved {
+    return {
+      kind: 'toml',
+      path: params.path,
+      params,
+      apply(report, reports, cwd) {
+        const filePath = path.resolve(cwd, params.path);
+        if (!fs.existsSync(filePath)) return;
+
+        let content = fs.readFileSync(filePath, 'utf8');
+
+        // Update package version inside the target Cargo.toml package block
+        content = content.replace(
+          /(\[package\][^]*?^version\s*=\s*")[^"]+(")/m,
+          `$1${report.newVersion}$2`,
+        );
+
+        // Sync workspace dependency entries if internal dependencies changed
+        for (const depReport of reports) {
+          if (depReport.name === report.name) continue;
+          const depRegex = new RegExp(
+            `(${depReport.name}\\s*=\\s*\\{[^}]*version\\s*=\\s*")[^"]+(")`,
+            'g',
+          );
+          content = content.replace(depRegex, `$1${depReport.newVersion}$2`);
+        }
+
+        fs.writeFileSync(filePath, content);
+      },
+    };
+  },
+});

package/src/vcs/git.ts

@@ -11,7 +11,11 @@ export function runGit(cmd: string, cwd: string): string {
 }
 
 function parseSemver(tag: string, prefix: string): number[] {
-  return tag.slice(prefix.length).split('.').map(Number);
+  const versionStr = tag.slice(prefix.length);
+  return versionStr.split('.').map((part) => {
+    const val = Number.parseInt(part, 10);
+    return Number.isNaN(val) ? 0 : val;
+  });
 }
 
 export function findLatestTag(tags: string[], prefix: string): string | null {
@@ -44,7 +48,6 @@ export function getGitCommits(
   const watchPaths = watch.join(' ');
   const range = lastTag ? `${lastTag}..HEAD` : 'HEAD';
 
-  // Using shell-safe single quotes and disabling signature lines to prevent parsing corruption
   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`;
@@ -90,7 +93,7 @@ export class GitVcsProvider implements VcsProvider {
     if (this.allTags === null) {
       this.allTags = runGit('git tag', this.cwd)
         .split('\n')
-        .map((t) => t.trim()) // Strips carriage returns (\r) and trailing whitespaces
+        .map((t) => t.trim())
         .filter(Boolean);
     }
     return this.allTags;
@@ -101,6 +104,24 @@ export class GitVcsProvider implements VcsProvider {
     return getGitCommits(name, watch, tags, this.cwd);
   }
 
+  async getLatestTag(name?: string): Promise<string | null> {
+    const tags = this.getAllTags();
+
+    if (typeof name === 'string') {
+      // Check specific crate tag first (e.g., "my_crate-v1.0.0")
+      const specificPrefix = `${name}-v`;
+      const specificTag = findLatestTag(tags, specificPrefix);
+      if (specificTag) return specificTag.slice(specificPrefix.length);
+    } else {
+      // Fallback to global release tag (e.g., "v1.0.0")
+      const genericPrefix = 'v';
+      const genericTag = findLatestTag(tags, genericPrefix);
+      if (genericTag) return genericTag.slice(genericPrefix.length);
+    }
+
+    return null;
+  }
+
   async commit(message: string): Promise<void> {
     runGit('git add .', this.cwd);
     runGit(`git commit -m "${message}"`, this.cwd);

package/src/vcs/index.ts

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

package/src/vcs/jj.ts

@@ -15,7 +15,11 @@ export function runJj(cmd: string, cwd: string): string {
 }
 
 function parseSemver(tag: string, prefix: string): number[] {
-  return tag.slice(prefix.length).split('.').map(Number);
+  const versionStr = tag.slice(prefix.length);
+  return versionStr.split('.').map((part) => {
+    const val = Number.parseInt(part, 10);
+    return Number.isNaN(val) ? 0 : val;
+  });
 }
 
 export function findLatestJjTag(tags: string[], prefix: string): string | null {
@@ -46,15 +50,12 @@ export function getJjCommits(
 ): Commit[] {
   const lastTag = resolveJjTag(name, allTags);
 
-  // FIXED: Double quotes explicitly escape the literal tag name for the jj revset engine
   const range = lastTag ? `"${lastTag}"..@ & ~root()` : `::@ & ~root()`;
 
-  // Calling `.short(40)` to cast the CommitId into a 40-character hex String for template concatenation
   const template =
     'commit_id.short(40) ++ "|" ++ author.name() ++ "|" ++ author.timestamp().format("%Y-%m-%d") ++ "|" ++ description.first_line() ++ "\\n"';
 
   const watchPaths = watch.join(' ');
-  // Appending --color=never to strip ANSI escape codes so hashes can be parsed cleanly
   const jjCmd = watchPaths
     ? `log --no-graph -r '${range}' -T '${template}' -- ${watchPaths}`
     : `log --no-graph -r '${range}' -T '${template}'`;
@@ -98,7 +99,6 @@ export class JjVcsProvider implements VcsProvider {
 
   private getAllTags(): string[] {
     if (this.allTags === null) {
-      // Must enforce --color=never to prevent ANSI escape codes from failing the startsWith prefix checks
       const raw = runJj('tag list', this.cwd);
       this.allTags = raw
         .split('\n')
@@ -116,12 +116,29 @@ export class JjVcsProvider implements VcsProvider {
     return getJjCommits(name, watch, tags, this.cwd);
   }
 
+  async getLatestTag(name?: string): Promise<string | null> {
+    const tags = this.getAllTags();
+
+    if (typeof name === 'string') {
+      // Check specific crate tag first
+      const specificPrefix = `${name}-v`;
+      const specificTag = findLatestJjTag(tags, specificPrefix);
+      if (specificTag) return specificTag.slice(specificPrefix.length);
+    } else {
+      // Fallback to global release tag
+      const genericPrefix = 'v';
+      const genericTag = findLatestJjTag(tags, genericPrefix);
+      if (genericTag) return genericTag.slice(genericPrefix.length);
+    }
+
+    return null;
+  }
+
   async commit(message: string): Promise<void> {
     runJj(`commit -m "${message}"`, this.cwd);
   }
 
   async tag(tagName: string): Promise<void> {
-    // Appending --allow-move to update the tag reference cleanly if it already exists
     runJj(`tag set "${tagName}" -r @- --allow-move`, this.cwd);
   }
 }