@fuzdev/fuz_gitops 0.57.0

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@fuzdev/fuz_gitops",
+  "version": "0.57.0",
+  "description": "a tool for managing many repos",
+  "glyph": "🪄",
+  "logo": "logo.svg",
+  "logo_alt": "a friendly blue spider facing you",
+  "public": true,
+  "license": "MIT",
+  "homepage": "https://gitops.fuz.dev/",
+  "repository": "https://github.com/fuzdev/fuz_gitops",
+  "author": {
+    "name": "Ryan Atkinson",
+    "email": "mail@ryanatkn.com",
+    "url": "https://www.ryanatkn.com/"
+  },
+  "bugs": "https://github.com/fuzdev/fuz_gitops/issues",
+  "funding": "https://www.ryanatkn.com/funding",
+  "scripts": {
+    "start": "gro dev",
+    "dev": "gro dev",
+    "build": "gro build",
+    "check": "gro check",
+    "test": "gro test",
+    "preview": "vite preview",
+    "deploy": "gro deploy"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.15"
+  },
+  "peerDependencies": {
+    "@fuzdev/fuz_css": ">=0.40.0",
+    "@fuzdev/fuz_ui": ">=0.169.0",
+    "@fuzdev/fuz_util": ">=0.42.0",
+    "@ryanatkn/gro": ">=0.181.0",
+    "@sveltejs/kit": "^2",
+    "svelte": "^5",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@changesets/changelog-git": "^0.2.1",
+    "@fuzdev/fuz_code": "^0.37.0",
+    "@fuzdev/fuz_css": "^0.40.0",
+    "@fuzdev/fuz_ui": "^0.169.0",
+    "@fuzdev/fuz_util": "^0.42.0",
+    "@ryanatkn/eslint-config": "^0.9.0",
+    "@ryanatkn/gro": "^0.181.0",
+    "@sveltejs/adapter-static": "^3.0.10",
+    "@sveltejs/kit": "^2.49.0",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@types/node": "^24.10.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-svelte": "^3.13.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-svelte": "^3.4.0",
+    "svelte": "^5.45.2",
+    "svelte-check": "^4.3.4",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.0",
+    "vitest": "^4.0.14"
+  },
+  "prettier": {
+    "plugins": [
+      "prettier-plugin-svelte"
+    ],
+    "useTabs": true,
+    "printWidth": 100,
+    "singleQuote": true,
+    "bracketSpacing": false,
+    "overrides": [
+      {
+        "files": "package.json",
+        "options": {
+          "useTabs": false
+        }
+      }
+    ]
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "files": [
+    "dist",
+    "src/lib/**/*.ts",
+    "!src/lib/**/*.test.*",
+    "!dist/**/*.test.*"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    "./*.js": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./*.ts": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./*.svelte": {
+      "types": "./dist/*.svelte.d.ts",
+      "svelte": "./dist/*.svelte",
+      "default": "./dist/*.svelte"
+    }
+  }
+}

package/src/lib/changeset_generator.ts

@@ -0,0 +1,162 @@
+/**
+ * Auto-generation of changesets for dependency updates during publishing.
+ *
+ * Creates changesets when packages need to republish due to updated dependencies.
+ * For parsing existing changesets, see `changeset_reader.ts`.
+ */
+
+import {writeFile, mkdir} from 'node:fs/promises';
+import {join} from 'node:path';
+import {existsSync} from 'node:fs';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {LocalRepo} from './local_repo.js';
+import type {PublishedVersion} from './multi_repo_publisher.js';
+import {strip_version_prefix} from './version_utils.js';
+
+export interface DependencyVersionChange {
+	package_name: string;
+	from_version: string;
+	to_version: string;
+	bump_type: 'major' | 'minor' | 'patch';
+	breaking: boolean;
+}
+
+/**
+ * Creates a changeset file for dependency updates.
+ * Returns the path to the created changeset file.
+ */
+export const create_changeset_for_dependency_updates = async (
+	repo: LocalRepo,
+	updates: Array<DependencyVersionChange>,
+	options: {log?: Logger} = {},
+): Promise<string> => {
+	const {log} = options;
+	const changesets_dir = join(repo.repo_dir, '.changeset');
+
+	// Ensure .changeset directory exists
+	if (!existsSync(changesets_dir)) {
+		await mkdir(changesets_dir, {recursive: true});
+	}
+
+	// Generate a unique filename
+	const timestamp = Date.now();
+	const random = Math.random().toString(36).substring(2, 8);
+	const filename = `dependency-update-${timestamp}-${random}.md`;
+	const filepath = join(changesets_dir, filename);
+
+	// Determine the required bump type based on updates
+	const required_bump = calculate_required_bump(repo, updates);
+
+	// Generate changeset content
+	const content = generate_changeset_content(repo.library.name, updates, required_bump);
+
+	// Write the changeset file
+	await writeFile(filepath, content, 'utf8');
+
+	log?.info(`  Created changeset: ${filename}`);
+
+	return filepath;
+};
+
+const calculate_required_bump = (
+	repo: LocalRepo,
+	updates: Array<DependencyVersionChange>,
+): 'major' | 'minor' | 'patch' => {
+	const current_version = repo.library.package_json.version || '0.0.0';
+	const [major] = current_version.split('.').map(Number);
+	const is_pre_1_0 = major === 0;
+
+	// Check if any dependency had breaking changes
+	const has_breaking = updates.some((u) => u.breaking);
+
+	if (has_breaking) {
+		// Breaking changes propagate
+		// Pre-1.0: use minor for breaking changes
+		// 1.0+: use major for breaking changes
+		return is_pre_1_0 ? 'minor' : 'major';
+	}
+
+	// For non-breaking dependency updates, always use patch
+	return 'patch';
+};
+
+/**
+ * Generates markdown changeset content for dependency updates.
+ *
+ * Creates properly formatted changeset with YAML frontmatter, summary,
+ * and categorized list of breaking vs regular updates. Output format
+ * matches changesets CLI for consistency.
+ *
+ * @param package_name package receiving the dependency updates
+ * @param updates list of dependency changes with version info
+ * @param bump_type required bump type (calculated from breaking changes)
+ * @returns markdown content ready to write to .changeset/*.md file
+ */
+export const generate_changeset_content = (
+	package_name: string,
+	updates: Array<DependencyVersionChange>,
+	bump_type: 'major' | 'minor' | 'patch',
+): string => {
+	// Group updates by type
+	const breaking_updates = updates.filter((u) => u.breaking);
+	const regular_updates = updates.filter((u) => !u.breaking);
+
+	let message = 'Update dependencies';
+
+	if (breaking_updates.length > 0) {
+		message = 'Update dependencies (BREAKING CHANGES)';
+	}
+
+	const lines: Array<string> = ['---', `"${package_name}": ${bump_type}`, '---', '', message, ''];
+
+	if (breaking_updates.length > 0) {
+		lines.push('Breaking dependency changes:');
+		for (const update of breaking_updates) {
+			lines.push(
+				`- ${update.package_name}: ${update.from_version} → ${update.to_version} (${update.bump_type})`,
+			);
+		}
+		lines.push('');
+	}
+
+	if (regular_updates.length > 0) {
+		if (breaking_updates.length > 0) {
+			lines.push('Other dependency updates:');
+		} else {
+			lines.push('Updated dependencies:');
+		}
+		for (const update of regular_updates) {
+			lines.push(
+				`- ${update.package_name}: ${update.from_version} → ${update.to_version} (${update.bump_type})`,
+			);
+		}
+		lines.push('');
+	}
+
+	return lines.join('\n');
+};
+
+export const create_dependency_updates = (
+	dependencies: Map<string, string>,
+	published_versions: Map<string, PublishedVersion>,
+): Array<DependencyVersionChange> => {
+	const updates: Array<DependencyVersionChange> = [];
+
+	for (const [dep_name, current_version] of dependencies) {
+		const published = published_versions.get(dep_name);
+		if (published) {
+			// Strip version prefix (^, ~, etc)
+			const clean_current = strip_version_prefix(current_version);
+
+			updates.push({
+				package_name: dep_name,
+				from_version: clean_current,
+				to_version: published.new_version,
+				bump_type: published.bump_type,
+				breaking: published.breaking,
+			});
+		}
+	}
+
+	return updates;
+};

package/src/lib/changeset_reader.ts

@@ -0,0 +1,218 @@
+/**
+ * Changeset parsing and version prediction from `.changeset/*.md` files.
+ *
+ * Reads changesets to determine which packages need publishing and their version bumps.
+ * For auto-generating changesets during publishing, see `changeset_generator.ts`.
+ */
+
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {existsSync} from 'node:fs';
+import {readdir, readFile} from 'node:fs/promises';
+import {join} from 'node:path';
+
+import type {LocalRepo} from './local_repo.js';
+import type {BumpType} from './semver.js';
+import {compare_bump_types, calculate_next_version} from './version_utils.js';
+
+export interface ChangesetInfo {
+	filename: string;
+	packages: Array<{name: string; bump_type: BumpType}>;
+	summary: string;
+}
+
+/**
+ * Parses changeset content string from markdown format.
+ *
+ * Pure function for testability - no file I/O, just string parsing.
+ * Extracts package names, bump types, and summary from YAML frontmatter format.
+ * Returns null if format is invalid or no packages found.
+ *
+ * Expected format:
+ * ---
+ * "package-name": patch
+ * "@scope/package": minor
+ * ---
+ *
+ * Summary of changes
+ *
+ * @param content changeset markdown with YAML frontmatter
+ * @param filename optional filename for error reporting context
+ * @returns parsed changeset info or null if invalid format
+ */
+export const parse_changeset_content = (
+	content: string,
+	filename = 'changeset.md',
+): ChangesetInfo | null => {
+	// Match frontmatter between --- markers
+	const frontmatter_match = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)/.exec(content);
+	if (!frontmatter_match) {
+		return null;
+	}
+
+	const frontmatter = frontmatter_match[1]!;
+	const summary = frontmatter_match[2]!.trim();
+
+	// Parse package entries
+	const packages: Array<{name: string; bump_type: BumpType}> = [];
+
+	// Match lines like: "package-name": patch
+	// or: '@scope/package': minor
+	// Allow leading whitespace
+	const package_regex = /^\s*["']([^"']+)["']\s*:\s*(major|minor|patch)\s*$/gm;
+	let match;
+
+	while ((match = package_regex.exec(frontmatter)) !== null) {
+		packages.push({
+			name: match[1]!,
+			bump_type: match[2]! as BumpType,
+		});
+	}
+
+	if (packages.length === 0) {
+		return null;
+	}
+
+	return {
+		filename,
+		packages,
+		summary,
+	};
+};
+
+export const parse_changeset_file = async (
+	filepath: string,
+	log?: Logger,
+): Promise<ChangesetInfo | null> => {
+	try {
+		const content = await readFile(filepath, 'utf8');
+		const filename = filepath.split('/').pop() || '';
+
+		const result = parse_changeset_content(content, filename);
+
+		if (!result) {
+			log?.warn(`  Invalid changeset format in ${filepath}`);
+		}
+
+		return result;
+	} catch (error) {
+		log?.error(`  Failed to parse changeset ${filepath}: ${error}`);
+		return null;
+	}
+};
+
+export const read_changesets = async (
+	repo: LocalRepo,
+	log?: Logger,
+): Promise<Array<ChangesetInfo>> => {
+	const changesets_dir = join(repo.repo_dir, '.changeset');
+
+	try {
+		const files = await readdir(changesets_dir);
+		const changeset_files = files.filter((f) => f.endsWith('.md') && f !== 'README.md');
+
+		const changesets: Array<ChangesetInfo> = [];
+
+		for (const file of changeset_files) {
+			const filepath = join(changesets_dir, file);
+			const changeset = await parse_changeset_file(filepath, log); // eslint-disable-line no-await-in-loop
+			if (changeset) {
+				changesets.push(changeset);
+			}
+		}
+
+		return changesets;
+	} catch (_error) {
+		// No .changeset directory or error reading
+		return [];
+	}
+};
+
+/**
+ * Determines the bump type for a package from its changesets.
+ *
+ * When multiple changesets exist for the same package, returns the highest
+ * bump type (major > minor > patch) to ensure the most significant change
+ * is reflected in the version bump.
+ *
+ * @returns the highest bump type, or null if package has no changesets
+ */
+export const determine_bump_from_changesets = (
+	changesets: Array<ChangesetInfo>,
+	package_name: string,
+): BumpType | null => {
+	let highest_bump: BumpType | null = null;
+
+	for (const changeset of changesets) {
+		for (const pkg of changeset.packages) {
+			if (pkg.name === package_name) {
+				if (!highest_bump || compare_bump_types(pkg.bump_type, highest_bump) > 0) {
+					highest_bump = pkg.bump_type;
+				}
+			}
+		}
+	}
+
+	return highest_bump;
+};
+
+/**
+ * Checks if a repo has any changeset files (excluding README.md).
+ *
+ * Used by preflight checks and publishing workflow to determine which packages
+ * need to be published. Returns false if .changeset directory doesn't exist
+ * or contains only README.md.
+ *
+ * @returns true if repo has unpublished changesets
+ */
+export const has_changesets = async (repo: LocalRepo): Promise<boolean> => {
+	const changesets_dir = join(repo.repo_dir, '.changeset');
+	if (!existsSync(changesets_dir)) {
+		return false;
+	}
+
+	try {
+		const files = await readdir(changesets_dir);
+		// Look for markdown files that aren't the README
+		return files.some((file) => file.endsWith('.md') && file !== 'README.md');
+	} catch {
+		return false;
+	}
+};
+
+/**
+ * Predicts the next version by analyzing all changesets in a repo.
+ *
+ * Reads all changesets, determines the highest bump type for the package,
+ * and calculates the next version. Returns null if no changesets found.
+ *
+ * Critical for dry-run mode accuracy - allows simulating publishes without
+ * actually running `gro publish` which consumes changesets.
+ *
+ * @returns predicted version and bump type, or null if no changesets
+ */
+export const predict_next_version = async (
+	repo: LocalRepo,
+	log?: Logger,
+): Promise<{version: string; bump_type: BumpType} | null> => {
+	const changesets = await read_changesets(repo, log);
+	if (changesets.length === 0) {
+		return null;
+	}
+
+	const bump_type = determine_bump_from_changesets(changesets, repo.library.name);
+	if (!bump_type) {
+		return null;
+	}
+
+	const current_version = repo.library.package_json.version || '0.0.0';
+	const next_version = calculate_next_version(current_version, bump_type);
+
+	log?.debug(
+		`  Predicted ${repo.library.name}: ${current_version} → ${next_version} (${bump_type})`,
+	);
+
+	return {
+		version: next_version,
+		bump_type,
+	};
+};

package/src/lib/constants.ts

@@ -0,0 +1,8 @@
+/**
+ * Maximum number of iterations for fixed-point iteration during publishing.
+ * Used in both plan generation and actual publishing to resolve transitive dependency cascades.
+ *
+ * In practice, most repos converge in 2-3 iterations.
+ * Deep dependency chains may require more iterations.
+ */
+export const MAX_ITERATIONS = 10;