relacher 0.0.1

package/src/builder/pnpm.ts

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { DependencyConfig } from '../types';
+
+import { decorateList, type DependencyList } from './shared';
+
+/**
+ * Loads a single project package configuration from package.json.
+ */
+export function pnpmProject(cwd: string): DependencyList {
+  const configs: DependencyConfig[] = [];
+  const pJsonPath = path.join(cwd, 'package.json');
+
+  if (fs.existsSync(pJsonPath)) {
+    try {
+      const fileContent = fs.readFileSync(pJsonPath, 'utf8');
+      const parsed = JSON.parse(fileContent);
+      if (parsed.name) {
+        configs.push({
+          name: parsed.name,
+          watch: ['.'],
+          depends: [],
+          updates: [
+            {
+              kind: 'regex',
+              path: 'package.json',
+              search: '"version"\\s*:\\s*"[^"]+"',
+              replace: '"version": "{{version}}"',
+            },
+          ],
+        });
+      }
+    } catch { }
+  }
+
+  return decorateList(configs);
+}
+
+/**
+ * Parses pnpm-workspace.yaml to identify target members and versioning topologies.
+ */
+export function pnpmWorkspace(cwd: string): DependencyList {
+  const configs: DependencyConfig[] = [];
+  const workspaceYamlPath = path.join(cwd, 'pnpm-workspace.yaml');
+  let globPatterns: string[] = [];
+
+  if (fs.existsSync(workspaceYamlPath)) {
+    const content = fs.readFileSync(workspaceYamlPath, 'utf8');
+    const lines = content.split('\n');
+    let inPackages = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('packages:')) {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        if (trimmed && !line.startsWith(' ') && !trimmed.startsWith('-')) {
+          inPackages = false;
+          continue;
+        }
+        const match = trimmed.match(/^-\s*['"]?([^'"]+)['"]?/);
+        if (match && match[1]) {
+          globPatterns.push(match[1]);
+        }
+      }
+    }
+  }
+
+  const packageInfos: { name: string; memberPath: string; content: string }[] = [];
+
+  for (const pattern of globPatterns) {
+    const cleanPattern = pattern.replace(/\\/g, '/');
+    if (cleanPattern.endsWith('/*')) {
+      const parentDir = path.join(cwd, cleanPattern.slice(0, -2));
+      if (fs.existsSync(parentDir) && fs.statSync(parentDir).isDirectory()) {
+        const subdirs = fs.readdirSync(parentDir);
+        for (const subdir of subdirs) {
+          const pJsonPath = path.join(parentDir, subdir, 'package.json');
+          if (fs.existsSync(pJsonPath)) {
+            try {
+              const fileContent = fs.readFileSync(pJsonPath, 'utf8');
+              const parsed = JSON.parse(fileContent);
+              if (parsed.name) {
+                packageInfos.push({
+                  name: parsed.name,
+                  memberPath: path.dirname(pJsonPath),
+                  content: fileContent,
+                });
+              }
+            } catch { }
+          }
+        }
+      }
+    } else {
+      const pJsonPath = path.join(cwd, cleanPattern, 'package.json');
+      if (fs.existsSync(pJsonPath)) {
+        try {
+          const fileContent = fs.readFileSync(pJsonPath, 'utf8');
+          const parsed = JSON.parse(fileContent);
+          if (parsed.name) {
+            packageInfos.push({
+              name: parsed.name,
+              memberPath: path.dirname(pJsonPath),
+              content: fileContent,
+            });
+          }
+        } catch { }
+      }
+    }
+  }
+
+  for (const info of packageInfos) {
+    const relativePath = path.relative(cwd, info.memberPath);
+    const relativePJson = path.join(relativePath, 'package.json');
+
+    const parsed = JSON.parse(info.content);
+    const depends: string[] = [];
+
+    const allDeps = {
+      ...parsed.dependencies,
+      ...parsed.devDependencies,
+      ...parsed.peerDependencies,
+    };
+
+    for (const other of packageInfos) {
+      if (other.name === info.name) continue;
+      if (allDeps[other.name] !== undefined) {
+        depends.push(other.name);
+      }
+    }
+
+    configs.push({
+      name: info.name,
+      watch: [relativePath],
+      depends,
+      updates: [
+        {
+          kind: 'regex',
+          path: relativePJson,
+          search: '"version"\\s*:\\s*"[^"]+"',
+          replace: '"version": "{{version}}"',
+        },
+      ],
+    });
+  }
+
+  return decorateList(configs);
+}
+
+/**
+ * Auto-detects whether the workspace configuration exists, reverting to single packages.
+ */
+export function pnpmDeps(cwd: string): DependencyList {
+  const workspaceYamlPath = path.join(cwd, 'pnpm-workspace.yaml');
+  if (fs.existsSync(workspaceYamlPath)) {
+    return pnpmWorkspace(cwd);
+  }
+  return pnpmProject(cwd);
+}

package/src/builder/shared.ts

@@ -0,0 +1,37 @@
+import type { ChangelogUpdate, RegexUpdate, DependencyConfig, UpdateAction } from '../types';
+
+export function changelogUpdate(options: Omit<ChangelogUpdate, 'kind'>): ChangelogUpdate {
+  return { kind: 'changelog', ...options };
+}
+
+export function regexUpdate(options: Omit<RegexUpdate, 'kind'>): RegexUpdate {
+  return { kind: 'regex', ...options };
+}
+
+export class SingleDependencyBuilder {
+  constructor(private config: DependencyConfig) { }
+
+  update(action: UpdateAction): this {
+    if (!this.config.updates) {
+      this.config.updates = [];
+    }
+    this.config.updates.push(action);
+    return this;
+  }
+}
+
+export interface DependencyList extends Array<DependencyConfig> {
+  on(name: string, cb: (builder: SingleDependencyBuilder) => void): this;
+}
+
+export function decorateList(configs: DependencyConfig[]): DependencyList {
+  const list = configs as DependencyList;
+  list.on = function(name: string, cb: (builder: SingleDependencyBuilder) => void) {
+    const dep = this.find((d) => d.name === name);
+    if (dep) {
+      cb(new SingleDependencyBuilder(dep));
+    }
+    return this;
+  };
+  return list;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './prepare';
+export * from './run';
+export * from './vcs';
+export * from './builder';
+export * from './print';
+export * from './types';

package/src/prepare.ts

@@ -0,0 +1,262 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  defaultSizes,
+  defaultCascadeRules,
+  type BumpSize,
+  type Commit,
+  type VcsProvider,
+  type DependencyConfig,
+  type DependencyUpdateReport,
+  type IntermediateReport,
+  type PrepareOptions,
+  type SizePatterns,
+  type CascadeRules,
+  type UpdateAction,
+  type ChangelogContext,
+} from './types';
+
+export function getTomlValue(content: string): string | null {
+  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 function bumpVersion(version: string, size: BumpSize): string {
+  const parts = version.split('.').map(Number);
+  if (parts.length !== 3 || parts.some(isNaN)) return version;
+  const major = parts[0];
+  const minor = parts[1];
+  const patch = parts[2];
+  if (major === undefined || minor === undefined || patch === undefined) return version;
+  if (size === 'major') return `${major + 1}.0.0`;
+  if (size === 'minor') return `${major}.${minor + 1}.0`;
+  if (size === 'patch') return `${major}.${minor}.${patch + 1}`;
+  return version;
+}
+
+export function getCurrentVersion(dep: DependencyConfig, cwd: string): string {
+  const tomlUpdate = dep.updates?.find((u) => u.kind === 'toml');
+  if (!tomlUpdate) return '0.0.0';
+  const filePath = path.resolve(cwd, tomlUpdate.path);
+  if (!fs.existsSync(filePath)) return '0.0.0';
+  return getTomlValue(fs.readFileSync(filePath, 'utf8')) || '0.0.0';
+}
+
+export function matchBumpSize(message: string, sizes: SizePatterns): BumpSize {
+  if (new RegExp(sizes.major.pattern).test(message)) return 'major';
+  if (new RegExp(sizes.minor.pattern).test(message)) return 'minor';
+  if (new RegExp(sizes.patch.pattern).test(message)) return 'patch';
+  return 'skip';
+}
+
+export function evaluateCommitsBump(commits: Commit[], sizes: SizePatterns): BumpSize {
+  const priority: Record<BumpSize, number> = { skip: 0, patch: 1, minor: 2, major: 3 };
+  let maxBump: BumpSize = 'skip';
+  for (const commit of commits) {
+    const commitBump = matchBumpSize(commit.message, sizes);
+    if (priority[commitBump] > priority[maxBump]) {
+      maxBump = commitBump;
+    }
+  }
+  return maxBump;
+}
+
+export function topologicalSort(items: IntermediateReport[]): IntermediateReport[] {
+  const processed = new Set<string>();
+  const processing = new Set<string>();
+  const sorted: IntermediateReport[] = [];
+  function visit(item: IntermediateReport) {
+    if (processing.has(item.name) || processed.has(item.name)) return;
+    processing.add(item.name);
+    for (const depName of item.depends) {
+      const depItem = items.find((r) => r.name === depName);
+      if (depItem) visit(depItem);
+    }
+    processing.delete(item.name);
+    processed.add(item.name);
+    sorted.push(item);
+  }
+  items.forEach((item) => visit(item));
+  return sorted;
+}
+
+export function propagateBumps(sorted: IntermediateReport[], rules?: CascadeRules): void {
+  const activeRules: Record<BumpSize, Record<BumpSize, BumpSize>> = {
+    skip: { ...defaultCascadeRules.skip, ...rules?.skip },
+    patch: { ...defaultCascadeRules.patch, ...rules?.patch },
+    minor: { ...defaultCascadeRules.minor, ...rules?.minor },
+    major: { ...defaultCascadeRules.major, ...rules?.major },
+  };
+
+  for (const item of sorted) {
+    let maxDepBump: BumpSize = 'skip';
+    for (const depName of item.depends) {
+      const depItem = sorted.find((r) => r.name === depName);
+      if (depItem) {
+        if (depItem.bump === 'major') {
+          maxDepBump = 'major';
+        } else if (depItem.bump === 'minor' && maxDepBump !== 'major') {
+          maxDepBump = 'minor';
+        } else if (depItem.bump === 'patch' && maxDepBump === 'skip') {
+          maxDepBump = 'patch';
+        }
+      }
+    }
+
+    if (maxDepBump !== 'skip') {
+      const original = item.bump;
+      const targetBump = activeRules[original][maxDepBump] ?? original;
+      item.bump = targetBump;
+    }
+
+    item.newVersion =
+      item.bump !== 'skip' ? bumpVersion(item.currentVersion, item.bump) : item.currentVersion;
+  }
+}
+
+export async function initReportItems(
+  cargoDeps: DependencyConfig[],
+  vcs: VcsProvider,
+  sizes: SizePatterns,
+  cwd: string,
+): Promise<IntermediateReport[]> {
+  const reports: IntermediateReport[] = [];
+  for (const dep of cargoDeps) {
+    const currentVersion = getCurrentVersion(dep, cwd);
+    const commits = await vcs.getCommits(dep.name, dep.watch || []);
+    const selfBump = evaluateCommitsBump(commits, sizes);
+    reports.push({
+      name: dep.name,
+      currentVersion,
+      newVersion: currentVersion,
+      bump: selfBump,
+      originalBump: selfBump,
+      commits,
+      updates: dep.updates || [],
+      depends: dep.depends || [],
+    });
+  }
+  return reports;
+}
+
+export async function prepare(
+  cargoDeps: DependencyConfig[],
+  vcs: VcsProvider,
+  options: PrepareOptions = {},
+): Promise<DependencyUpdateReport[]> {
+  const cwd = options.cwd || process.cwd();
+  const sizes = options.sizes || defaultSizes;
+  const items = await initReportItems(cargoDeps, vcs, sizes, cwd);
+  const sorted = topologicalSort(items);
+  propagateBumps(sorted, options.cascade);
+  return finalizeReports(sorted);
+}
+
+export function buildChangelogBlock(version: string, commits: Commit[]): string {
+  const date = new Date().toISOString().split('T')[0] ?? '';
+  let block = `## [${version}] - ${date}\n\n`;
+
+  if (commits.length === 0) {
+    return block + `*No notable changes.*\n`;
+  }
+
+  const breaking: string[] = [];
+  const features: string[] = [];
+  const fixes: string[] = [];
+  const others: string[] = [];
+
+  for (const c of commits) {
+    if (c.message.includes('!:') || c.message.includes('BREAKING CHANGE')) {
+      breaking.push(`- ${c.hash} ${c.message}`);
+    } else if (c.message.startsWith('feat')) {
+      features.push(`- ${c.hash} ${c.message}`);
+    } else if (c.message.startsWith('fix')) {
+      fixes.push(`- ${c.hash} ${c.message}`);
+    } else {
+      others.push(`- ${c.hash} ${c.message}`);
+    }
+  }
+
+  if (breaking.length) block += `### ⚠️ BREAKING CHANGES\n${breaking.join('\n')}\n\n`;
+  if (features.length) block += `### ✨ Features\n${features.join('\n')}\n\n`;
+  if (fixes.length) block += `### 🐛 Bug Fixes\n${fixes.join('\n')}\n\n`;
+  if (others.length) block += `### 🛠 Other Changes\n${others.join('\n')}\n\n`;
+
+  return block.trim() + '\n';
+}
+
+export function finalizeReports(sorted: IntermediateReport[]): DependencyUpdateReport[] {
+  const allCommitsMap = new Map<string, Commit>();
+  for (const item of sorted) {
+    for (const c of item.commits) {
+      allCommitsMap.set(c.hash, c);
+    }
+  }
+  const globalCommits = Array.from(allCommitsMap.values());
+
+  return sorted.map((item) => ({
+    name: item.name,
+    currentVersion: item.currentVersion,
+    newVersion: item.newVersion,
+    bump: item.bump,
+    originalBump: item.originalBump,
+    commits: item.commits,
+    updates: mapResolvedUpdates(item.updates, item.newVersion, item.commits, globalCommits),
+    depends: item.depends,
+  }));
+}
+
+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';
+}
+
+export function mapResolvedUpdates(
+  updates: UpdateAction[],
+  newVersion: string,
+  crateCommits: Commit[],
+  globalCommits: Commit[],
+): UpdateAction[] {
+  return updates.map((u) => {
+    if (u.kind === 'regex') {
+      return { ...u, resolvedReplace: u.replace.replace('{{version}}', newVersion) };
+    }
+    if (u.kind === 'changelog') {
+      const targetCommits = u.global ? globalCommits : crateCommits;
+      const context: ChangelogContext = {
+        version: newVersion,
+        date: new Date().toISOString().split('T')[0] ?? '',
+        commits: targetCommits,
+      };
+
+      const content = u.template ? u.template(context) : defaultChangelogTemplate(context);
+      return { ...u, resolvedBlock: content };
+    }
+    return u;
+  });
+}

package/src/print.ts

@@ -0,0 +1,109 @@
+import { matchBumpSize } from './prepare';
+import { defaultSizes } from './types';
+import type { DependencyUpdateReport } from './types';
+
+// ANSI Escape Codes for Terminal Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+/**
+ * Highlights only the changed segments of a version string.
+ * Example: "1.2.3" -> "1.3.0" prints "1.2.3 → 1.[3.0]" where [3.0] is bright green.
+ */
+function highlightVersion(oldV: string, newV: string): string {
+  if (oldV === newV) return `${c.gray}${oldV} (no change)${c.reset}`;
+
+  const oParts = oldV.split('.');
+  const nParts = newV.split('.');
+
+  let matchIdx = 0;
+  while (matchIdx < 3 && oParts[matchIdx] === nParts[matchIdx]) {
+    matchIdx++;
+  }
+
+  const common = nParts.slice(0, matchIdx).join('.') + (matchIdx > 0 ? '.' : '');
+  const changed = nParts.slice(matchIdx).join('.');
+
+  return `${c.gray}${oldV}${c.reset} ${c.magenta}→${c.reset} ${c.gray}${common}${c.reset}${c.green}${c.bold}${changed}${c.reset}`;
+}
+
+function getIconForFile(filename: string): string {
+  const ext = filename.split('.').pop()?.toLowerCase() || '';
+
+  const icons: Record<string, string> = {
+    toml: '',
+    nix: '',
+    md: '',
+    mdx: '',
+    rs: '',
+    js: '',
+    ts: '',
+    json: '',
+    yaml: '',
+    yml: '',
+    lock: '',
+    log: '󰌱',
+  };
+
+  return icons[ext] || '󰈚'; // Default file icon
+}
+export function prettyPrint(reports: DependencyUpdateReport[]): void {
+  for (const report of reports) {
+    if (report.bump === 'skip') continue;
+
+    const bumpColor =
+      report.bump === 'major' ? c.red : report.bump === 'minor' ? c.yellow : c.green;
+    process.stdout.write(
+      `${c.bold}📦 ${report.name.padEnd(12)}${c.reset} ${highlightVersion(report.currentVersion, report.newVersion)} ${bumpColor}${c.bold}[${report.bump}]${c.reset}\n`,
+    );
+
+    const files = report.updates.map(
+      (u) =>
+        `${getIconForFile(u.path.split('/').pop() || '')} ${c.dim}${u.path.split('/').pop()}${c.reset}`,
+    );
+    console.log(`   ${files.join('  ')}`);
+
+    // 1. Show all commits since the last release with a bump marker if applicable
+    for (const commit of report.commits) {
+      const commitBump = matchBumpSize(commit.message, defaultSizes);
+      const affectsBump = commitBump !== 'skip';
+
+      const marker = affectsBump ? `${c.green}✦${c.reset}` : `${c.gray}○${c.reset}`;
+
+      console.log(
+        `     ${marker} ${c.yellow}${commit.shortHash}${c.reset} ${commit.message}  ${c.gray}${commit.author} ${commit.date}${c.reset}`,
+      );
+    }
+
+    // 2. Show Cascades with their update kind
+    const changedDeps = reports.filter(
+      (r) => report.depends?.includes(r.name) && r.currentVersion !== r.newVersion,
+    );
+
+    if (changedDeps.length > 0) {
+      const depsStr = changedDeps
+        .map((d) => {
+          const depBumpColor = d.bump === 'major' ? c.red : d.bump === 'minor' ? c.yellow : c.green;
+          return `${c.blue}${d.name}${c.reset} ${depBumpColor}[${d.bump}]${c.reset}`;
+        })
+        .join(', ');
+
+      console.log(
+        `     ${c.green}✦${c.reset} Cascaded as ${bumpColor}[${report.bump}]${c.reset} from deps: ${depsStr}`,
+      );
+    }
+
+    // Changelog Preview
+    console.log('');
+  }
+}

package/src/run.ts

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { DependencyUpdateReport, VcsProvider } from './types';
+
+/**
+ * Applies calculated updates to files on disk, stages, commits, and tags using the provided VcsProvider.
+ */
+export async function run(
+  reports: DependencyUpdateReport[],
+  vcs: VcsProvider,
+  options: { cwd: string },
+): Promise<void> {
+  const cwd = options.cwd;
+
+  // 1. Apply file updates
+  for (const report of reports) {
+    for (const u of report.updates) {
+      const filePath = path.resolve(cwd, u.path);
+      const dirPath = path.dirname(filePath);
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+      }
+
+      if (u.kind === 'toml') {
+        if (fs.existsSync(filePath)) {
+          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);
+        }
+      } else if (u.kind === 'regex') {
+        if (fs.existsSync(filePath)) {
+          let content = fs.readFileSync(filePath, 'utf8');
+          const searchRegex = new RegExp(u.search, 'g');
+          content = content.replace(searchRegex, u.resolvedReplace ?? '');
+          fs.writeFileSync(filePath, content);
+        }
+      } else if (u.kind === 'changelog') {
+        const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+        const newContent = (u.resolvedBlock ?? '') + '\n' + oldContent;
+        fs.writeFileSync(filePath, newContent.trim() + '\n');
+      }
+    }
+  }
+
+  // 2. Build multi-line commit message
+  const activeReports = reports.filter((r) => r.bump !== 'skip');
+  if (activeReports.length === 0) {
+    return;
+  }
+
+  const tagList = activeReports.map((r) => `${r.name}-v${r.newVersion}`).join(', ');
+  let commitMessage = `chore: release ${tagList}\n\n`;
+
+  for (const report of activeReports) {
+    commitMessage += `${report.name} (${report.currentVersion} -> ${report.newVersion}) [${report.bump}]\n`;
+
+    // Add commits
+    for (const commit of report.commits) {
+      commitMessage += `  - ${commit.shortHash} ${commit.message} (${commit.author} ${commit.date})\n`;
+    }
+
+    // Add cascades
+    const changedDeps = reports.filter(
+      (r) => report.depends?.includes(r.name) && r.currentVersion !== r.newVersion,
+    );
+
+    if (changedDeps.length > 0) {
+      const depsStr = changedDeps.map((d) => `${d.name} [${d.bump}]`).join(', ');
+      commitMessage += `  - Cascaded from deps: ${depsStr}\n`;
+    }
+
+    commitMessage += '\n';
+  }
+
+  // 3. Stage and execute commit
+  await vcs.commit(commitMessage.trim());
+
+  // 4. Create tags
+  for (const report of activeReports) {
+    const tagName = `${report.name}-v${report.newVersion}`;
+    await vcs.tag(tagName);
+  }
+}