@fuzdev/fuz_gitops 0.77.0 → 0.78.1

package/src/lib/gitops_sync.task.ts

@@ -1,18 +1,18 @@
-import {TaskError, type Task} from '@fuzdev/gro';
-import {z} from 'zod';
-import {readFile, writeFile} from 'node:fs/promises';
-import {format_file} from '@fuzdev/gro/format_file.js';
-import {basename, resolve} from 'node:path';
-import {print_path} from '@fuzdev/gro/paths.js';
-import {load_from_env} from '@fuzdev/gro/env.js';
-import {package_json_load} from '@fuzdev/gro/package_json.js';
-import {existsSync} from 'node:fs';
-import {compactReplacer} from 'svelte-docinfo';
-
-import {fetch_repo_data} from './fetch_repo_data.js';
-import {create_fs_fetch_value_cache} from './fs_fetch_value_cache.js';
-import {get_gitops_ready} from './gitops_task_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+import { TaskError, type Task } from '@fuzdev/gro';
+import { z } from 'zod';
+import { readFile, writeFile } from 'node:fs/promises';
+import { format_file } from '@fuzdev/gro/format_file.ts';
+import { basename, resolve } from 'node:path';
+import { print_path } from '@fuzdev/gro/paths.ts';
+import { load_from_env } from '@fuzdev/gro/env.ts';
+import { package_json_load } from '@fuzdev/gro/package_json.ts';
+import { existsSync } from 'node:fs';
+import { compactReplacer } from 'svelte-docinfo';
+
+import { fetch_repo_data } from './fetch_repo_data.ts';
+import { create_fs_fetch_value_cache } from './fs_fetch_value_cache.ts';
+import { get_gitops_ready } from './gitops_task_helpers.ts';
+import { GITOPS_CONFIG_PATH_DEFAULT } from './gitops_constants.ts';
 
 // TODO add flag to ignore or invalidate cache -- no-cache? clean?
 
@@ -20,28 +20,28 @@ import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
 export const Args = z.strictObject({
 	config: z
 		.string()
-		.meta({description: 'path to the gitops config file, absolute or relative to the cwd'})
+		.meta({ description: 'path to the gitops config file, absolute or relative to the cwd' })
 		.default(GITOPS_CONFIG_PATH_DEFAULT),
 	dir: z
 		.string()
-		.meta({description: 'path containing the repos, defaults to the parent of the config dir'})
+		.meta({ description: 'path containing the repos, defaults to the parent of the config dir' })
 		.optional(),
 	outdir: z
 		.string()
-		.meta({description: 'path to the directory for the generated files, defaults to $routes/'})
+		.meta({ description: 'path to the directory for the generated files, defaults to $routes/' })
 		.optional(),
-	download: z.boolean().meta({description: 'download all missing local repos'}).default(false),
+	download: z.boolean().meta({ description: 'download all missing local repos' }).default(false),
 	check: z
 		.boolean()
-		.meta({description: 'check repos are ready without fetching remote data'})
+		.meta({ description: 'check repos are ready without fetching remote data' })
 		.default(false),
 	allow_dirty: z
 		.boolean()
 		.meta({
 			description:
-				'sync (switch branch, pull) tolerating uncommitted changes instead of failing on a dirty workspace',
+				'sync (switch branch, pull) tolerating uncommitted changes instead of failing on a dirty workspace'
 		})
-		.default(false),
+		.default(false)
 });
 export type Args = z.infer<typeof Args>;
 
@@ -53,17 +53,26 @@ export type Args = z.infer<typeof Args>;
 export const task: Task<Args> = {
 	Args,
 	summary: 'syncs local repos and generates UI data from repo metadata',
-	run: async ({args, log, svelte_config, invoke_task}) => {
-		const {config, dir, outdir = svelte_config.routes_path, download, check, allow_dirty} = args;
+	run: async (ctx) => {
+		const { args, log, invoke_task } = ctx;
+		// `ctx.svelte_config` is a lazy getter, so it's only read when `outdir` isn't provided
+		const {
+			config,
+			dir,
+			outdir = (await ctx.svelte_config).routes_path,
+			download,
+			check,
+			allow_dirty
+		} = args;
 
 		// `gitops_sync` is the task whose job is to mutate working trees, so it always syncs.
-		const {local_repos} = await get_gitops_ready({
+		const { local_repos } = await get_gitops_ready({
 			config,
 			dir,
 			download,
 			sync: true,
 			allow_dirty,
-			log,
+			log
 		});
 
 		const outfile_json = resolve(outdir, 'repos.json');
@@ -96,8 +105,8 @@ export const task: Task<Args> = {
 		log.info(`generating ${outfile_json} and ${outfile_ts}`);
 
 		// Generate repos.json with the raw data
-		const json_contents = await format_file(JSON.stringify(repos_json, compactReplacer), {
-			filepath: outfile_json,
+		const json_contents = format_file(JSON.stringify(repos_json, compactReplacer), {
+			lang: 'json'
 		});
 		const existing_json = existsSync(outfile_json) ? await readFile(outfile_json, 'utf8') : '';
 		const json_changed = existing_json !== json_contents;
@@ -123,7 +132,7 @@ export const task: Task<Args> = {
 			export const repos_json: Array<RepoJson> = json as unknown as Array<RepoJson>;
 		`;
 		// TODO think about possibly using the `gen` functionality in this task, not sure what the API design could look like
-		const formatted_ts = await format_file(ts_contents, {filepath: outfile_ts});
+		const formatted_ts = format_file(ts_contents, { filepath: outfile_ts });
 		const existing_ts = existsSync(outfile_ts) ? await readFile(outfile_ts, 'utf8') : '';
 		if (existing_ts === formatted_ts) {
 			log.info(`no changes to ${print_path(outfile_ts)}`);
@@ -142,5 +151,5 @@ export const task: Task<Args> = {
 		} else {
 			log.info('repos cache did not change');
 		}
-	},
+	}
 };

package/src/lib/gitops_task_helpers.ts

@@ -16,17 +16,17 @@
  * @module
  */
 
-import {TaskError} from '@fuzdev/gro';
-import {styleText as st} from 'node:util';
-import {resolve, dirname} from 'node:path';
-import {print_path} from '@fuzdev/gro/paths.js';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import { TaskError } from '@fuzdev/gro';
+import { styleText as st } from 'node:util';
+import { resolve, dirname } from 'node:path';
+import { print_path } from '@fuzdev/gro/paths.ts';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
 
-import {load_gitops_config, type GitopsConfig} from './gitops_config.js';
-import {local_repos_load, local_repos_ensure, type LocalRepo} from './local_repo.js';
-import {resolve_gitops_config} from './resolved_gitops_config.js';
-import {DEFAULT_REPOS_DIR} from './paths.js';
-import type {GitOperations, NpmOperations} from './operations.js';
+import { load_gitops_config, type GitopsConfig } from './gitops_config.ts';
+import { local_repos_load, local_repos_ensure, type LocalRepo } from './local_repo.ts';
+import { resolve_gitops_config } from './resolved_gitops_config.ts';
+import { DEFAULT_REPOS_DIR } from './paths.ts';
+import type { GitOperations, NpmOperations } from './operations.ts';
 
 export interface GetGitopsReadyOptions {
 	config: string;
@@ -75,14 +75,14 @@ export interface GetGitopsReadyOptions {
  * @throws {TaskError} if config loading or repo resolution fails
  */
 export const get_gitops_ready = async (
-	options: GetGitopsReadyOptions,
+	options: GetGitopsReadyOptions
 ): Promise<{
 	config_path: string;
 	repos_dir: string;
 	gitops_config: GitopsConfig;
 	local_repos: Array<LocalRepo>;
 }> => {
-	const {config, dir, download, log, git_ops, npm_ops, parallel, concurrency, sync, allow_dirty} =
+	const { config, dir, download, log, git_ops, npm_ops, parallel, concurrency, sync, allow_dirty } =
 		options;
 	const config_path = resolve(config);
 	const gitops_config = await import_gitops_config(config_path);
@@ -91,12 +91,12 @@ export const get_gitops_ready = async (
 	const repos_dir = resolve_gitops_paths({
 		config,
 		dir,
-		config_repos_dir: gitops_config.repos_dir,
+		config_repos_dir: gitops_config.repos_dir
 	}).repos_dir;
 
 	log?.info(
 		`resolving gitops configs on the filesystem in ${repos_dir}`,
-		gitops_config.repos.map((r) => r.repo_url),
+		gitops_config.repos.map((r) => r.repo_url)
 	);
 	const resolved_config = resolve_gitops_config(gitops_config, repos_dir);
 
@@ -106,7 +106,7 @@ export const get_gitops_ready = async (
 		gitops_config,
 		download,
 		log,
-		npm_ops,
+		npm_ops
 	});
 
 	const local_repos = await local_repos_load({
@@ -117,10 +117,10 @@ export const get_gitops_ready = async (
 		parallel,
 		concurrency,
 		sync,
-		allow_dirty,
+		allow_dirty
 	});
 
-	return {config_path, repos_dir, gitops_config, local_repos};
+	return { config_path, repos_dir, gitops_config, local_repos };
 };
 
 export interface ResolveGitopsPathsOptions {
@@ -130,9 +130,9 @@ export interface ResolveGitopsPathsOptions {
 }
 
 export const resolve_gitops_paths = (
-	options: ResolveGitopsPathsOptions,
-): {config_path: string; repos_dir: string} => {
-	const {config, dir, config_repos_dir} = options;
+	options: ResolveGitopsPathsOptions
+): { config_path: string; repos_dir: string } => {
+	const { config, dir, config_repos_dir } = options;
 	const config_path = resolve(config);
 	const config_dir = dirname(config_path);
 
@@ -144,7 +144,7 @@ export const resolve_gitops_paths = (
 				? resolve(config_dir, config_repos_dir)
 				: resolve(config_dir, DEFAULT_REPOS_DIR);
 
-	return {config_path, repos_dir};
+	return { config_path, repos_dir };
 };
 
 export const import_gitops_config = async (config_path: string): Promise<GitopsConfig> => {

package/src/lib/gitops_validate.task.ts

@@ -1,37 +1,37 @@
-import type {Task} from '@fuzdev/gro';
-import {z} from 'zod';
-import {styleText as st} from 'node:util';
+import type { Task } from '@fuzdev/gro';
+import { z } from 'zod';
+import { styleText as st } from 'node:util';
 
-import {get_gitops_ready} from './gitops_task_helpers.js';
-import {analyze_repos, type DependencyAnalysis} from './graph_validation.js';
+import { get_gitops_ready } from './gitops_task_helpers.ts';
+import { analyze_repos, type DependencyAnalysis } from './graph_validation.ts';
 import {
 	generate_publishing_plan,
 	log_publishing_plan,
-	type PublishingPlan,
-} from './publishing_plan.js';
-import {execute_publishing_plan, type PublishingOptions} from './multi_repo_publisher.js';
-import {log_dependency_analysis} from './log_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
-import {reconcile_ci, repo_has_workflows} from './ci_reconcile.js';
+	type PublishingPlan
+} from './publishing_plan.ts';
+import { execute_publishing_plan, type PublishingOptions } from './multi_repo_publisher.ts';
+import { log_dependency_analysis } from './log_helpers.ts';
+import { GITOPS_CONFIG_PATH_DEFAULT } from './gitops_constants.ts';
+import { reconcile_ci, repo_has_workflows } from './ci_reconcile.ts';
 
 /** @nodocs */
 export const Args = z.strictObject({
 	config: z
 		.string()
-		.meta({description: 'path to the gitops config file, absolute or relative to the cwd'})
+		.meta({ description: 'path to the gitops config file, absolute or relative to the cwd' })
 		.default(GITOPS_CONFIG_PATH_DEFAULT),
 	dir: z
 		.string()
-		.meta({description: 'path containing the repos, defaults to the parent of the config dir'})
+		.meta({ description: 'path containing the repos, defaults to the parent of the config dir' })
 		.optional(),
-	verbose: z.boolean().meta({description: 'show additional details'}).default(false),
+	verbose: z.boolean().meta({ description: 'show additional details' }).default(false),
 	sync: z
 		.boolean()
 		.meta({
 			description:
-				'sync repos (switch branch, pull, install) before validating instead of reading the working tree as-is',
+				'sync repos (switch branch, pull, install) before validating instead of reading the working tree as-is'
 		})
-		.default(false),
+		.default(false)
 });
 export type Args = z.infer<typeof Args>;
 
@@ -40,8 +40,8 @@ export const task: Task<Args> = {
 	Args,
 	summary:
 		'validate gitops configuration by running all read-only commands and checking for issues',
-	run: async ({args, log}) => {
-		const {config, dir, verbose, sync} = args;
+	run: async ({ args, log }) => {
+		const { config, dir, verbose, sync } = args;
 
 		log.info(st('cyan', 'Running Gitops Validation Suite'));
 		log.info(st('dim', 'This runs all read-only commands and checks for consistency.'));
@@ -61,7 +61,7 @@ export const task: Task<Args> = {
 
 		// Load repos once (shared by all commands); read the working tree as-is unless `--sync`
 		log.info(st('dim', 'Loading repositories...'));
-		const {local_repos} = await get_gitops_ready({config, dir, download: false, sync, log});
+		const { local_repos } = await get_gitops_ready({ config, dir, download: false, sync, log });
 		log.info(st('dim', `   Found ${local_repos.length} local repos`));
 
 		// 1. Run gitops_analyze
@@ -69,7 +69,7 @@ export const task: Task<Args> = {
 		const analyze_start = Date.now();
 		try {
 			// Build dependency graph and analyze cycles/wildcards (tolerating cycles)
-			const {analysis} = analyze_repos(local_repos);
+			const { analysis } = analyze_repos(local_repos);
 
 			const analyze_duration = Date.now() - analyze_start;
 
@@ -93,7 +93,7 @@ export const task: Task<Args> = {
 				duration: analyze_duration,
 				warning_details,
 				info_details,
-				analysis,
+				analysis
 			});
 
 			log.info(st('green', `  ✓ gitops_analyze completed in ${analyze_duration}ms`));
@@ -111,7 +111,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: analyze_duration,
+				duration: analyze_duration
 			});
 			log.error(st('red', `  ✗ gitops_analyze failed: ${error}`));
 		}
@@ -121,7 +121,7 @@ export const task: Task<Args> = {
 		log.info(st('yellow', 'Running gitops_plan...'));
 		const plan_start = Date.now();
 		try {
-			const plan = await generate_publishing_plan(local_repos, {verbose});
+			const plan = await generate_publishing_plan(local_repos, { verbose });
 			publishing_plan = plan;
 			const plan_duration = Date.now() - plan_start;
 
@@ -133,12 +133,12 @@ export const task: Task<Args> = {
 				success: errors === 0,
 				warnings,
 				errors,
-				duration: plan_duration,
+				duration: plan_duration
 			});
 
 			log.info(st('green', `  ✓ gitops_plan completed in ${plan_duration}ms`));
 			if (verbose) {
-				log_publishing_plan(plan, log, {verbose});
+				log_publishing_plan(plan, log, { verbose });
 			}
 			if (warnings > 0) {
 				log.warn(st('yellow', `  ⚠️  Found ${warnings} warning(s)`));
@@ -153,7 +153,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: plan_duration,
+				duration: plan_duration
 			});
 			log.error(st('red', `  ✗ gitops_plan failed: ${error}`));
 		}
@@ -164,14 +164,14 @@ export const task: Task<Args> = {
 		try {
 			const options: PublishingOptions = {
 				wetrun: false,
-				log: undefined, // Silent for validation
+				log: undefined // Silent for validation
 			};
 
 			// Reuse the plan from step 2 (regenerate only if that step failed to produce one).
 			const result = await execute_publishing_plan(
 				local_repos,
-				publishing_plan ?? (await generate_publishing_plan(local_repos, {verbose})),
-				options,
+				publishing_plan ?? (await generate_publishing_plan(local_repos, { verbose })),
+				options
 			);
 			const dry_duration = Date.now() - dry_start;
 
@@ -184,7 +184,7 @@ export const task: Task<Args> = {
 				success: result.ok,
 				warnings: 0,
 				errors,
-				duration: dry_duration,
+				duration: dry_duration
 			});
 
 			log.info(st('green', `  ✓ gitops_publish (dry run) completed in ${dry_duration}ms`));
@@ -198,7 +198,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: dry_duration,
+				duration: dry_duration
 			});
 			log.error(st('red', `  ✗ gitops_publish (dry run) failed: ${error}`));
 		}
@@ -217,21 +217,21 @@ export const task: Task<Args> = {
 					// always `true` today. The gate exists for a future caller that loads a
 					// partial set; until then the skip path is inert and untested.
 					checkable: true,
-					archived: r.repo_config.archived,
-				})),
+					archived: r.repo_config.archived
+				}))
 			);
 			const ci_duration = Date.now() - ci_start;
 			const drift_details = ci_drift.map((d) =>
 				d.kind === 'missing_ci'
 					? `${d.repo_url}: ci=true but no workflow files`
-					: `${d.repo_url}: ci=false but workflow files present`,
+					: `${d.repo_url}: ci=false but workflow files present`
 			);
 			results.push({
 				command: 'ci_reconcile',
 				success: ci_drift.length === 0,
 				warnings: 0,
 				errors: ci_drift.length,
-				duration: ci_duration,
+				duration: ci_duration
 			});
 			if (ci_drift.length === 0) {
 				log.info(st('green', `  ✓ ci_reconcile completed in ${ci_duration}ms`));
@@ -248,7 +248,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: ci_duration,
+				duration: ci_duration
 			});
 			log.error(st('red', `  ✗ ci_reconcile failed: ${error}`));
 		}
@@ -295,7 +295,7 @@ export const task: Task<Args> = {
 			log.info(st('green', '✓ All validation checks passed'));
 			if (total_warnings > 0) {
 				log.warn(
-					st('yellow', `⚠️  Note: ${total_warnings} warning(s) found - review output above.`),
+					st('yellow', `⚠️  Note: ${total_warnings} warning(s) found - review output above.`)
 				);
 			}
 		} else {
@@ -305,5 +305,5 @@ export const task: Task<Args> = {
 			log.error(st('red', '❌ Validation failed - review the errors above.'));
 			throw new Error('Validation failed');
 		}
-	},
+	}
 };

package/src/lib/graph_validation.ts

@@ -13,12 +13,12 @@
  * @module
  */
 
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {TaskError} from '@fuzdev/gro';
-import {styleText as st} from 'node:util';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { TaskError } from '@fuzdev/gro';
+import { styleText as st } from 'node:util';
 
-import {DependencyGraph, DependencyGraphBuilder} from './dependency_graph.js';
-import type {LocalRepo} from './local_repo.js';
+import { DependencyGraph, DependencyGraphBuilder } from './dependency_graph.ts';
+import { repo_is_npm, type LocalRepo } from './local_repo.ts';
 
 export interface GraphValidationResult {
 	graph: DependencyGraph;
@@ -45,9 +45,9 @@ export const validate_dependency_graph = (
 		throw_on_prod_cycles?: boolean;
 		log_cycles?: boolean;
 		log_order?: boolean;
-	} = {},
+	} = {}
 ): GraphValidationResult => {
-	const {log, throw_on_prod_cycles = true, log_cycles = true, log_order = true} = options;
+	const { log, throw_on_prod_cycles = true, log_cycles = true, log_order = true } = options;
 
 	// Build dependency graph
 	log?.info('📊 Analyzing dependencies...');
@@ -55,7 +55,7 @@ export const validate_dependency_graph = (
 	const graph = builder.build_from_repos(repos);
 
 	// Check for cycles
-	const {production_cycles, dev_cycles} = graph.detect_cycles_by_type();
+	const { production_cycles, dev_cycles } = graph.detect_cycles_by_type();
 
 	// Log production cycles
 	if (production_cycles.length > 0 && log_cycles) {
@@ -67,7 +67,7 @@ export const validate_dependency_graph = (
 		if (throw_on_prod_cycles) {
 			throw new TaskError(
 				`Cannot publish with production/peer dependency cycles. ` +
-					`These must be resolved before publishing.`,
+					`These must be resolved before publishing.`
 			);
 		}
 	}
@@ -106,7 +106,7 @@ export const validate_dependency_graph = (
 		publishing_order,
 		production_cycles,
 		dev_cycles,
-		sort_error,
+		sort_error
 	};
 };
 
@@ -127,11 +127,12 @@ export interface RepoAnalysis {
  * (no `log`) to avoid emitting a redundant "Analyzing dependencies" line.
  */
 export const analyze_repos = (repos: Array<LocalRepo>): RepoAnalysis => {
-	const {graph, publishing_order: order} = validate_dependency_graph(repos, {
+	// Only npm packages form the dependency graph; non-npm repos (e.g. cargo) are excluded.
+	const { graph, publishing_order: order } = validate_dependency_graph(repos.filter(repo_is_npm), {
 		throw_on_prod_cycles: false, // report, don't throw
 		log_cycles: false, // callers format their own cycle output
-		log_order: false,
+		log_order: false
 	});
 	const analysis = new DependencyGraphBuilder().analyze(graph);
-	return {graph, analysis, publishing_order: order.length > 0 ? order : null};
+	return { graph, analysis, publishing_order: order.length > 0 ? order : null };
 };