@fuzdev/gro 0.192.0

package/src/lib/task_logging.ts

@@ -0,0 +1,255 @@
+import type {ArgSchema} from '@fuzdev/fuz_util/args.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {print_value} from '@fuzdev/fuz_util/print.js';
+import {plural} from '@fuzdev/fuz_util/string.js';
+import {styleText as st} from 'node:util';
+import {z} from 'zod';
+import type {LoadedTasks, TaskModuleMeta} from './task.ts';
+import {print_path} from './paths.ts';
+
+export const log_tasks = (log: Logger, loaded_tasks: LoadedTasks, log_intro = true): void => {
+	const {modules, found_tasks} = loaded_tasks;
+	const {resolved_input_files_by_root_dir} = found_tasks;
+
+	const logged: Array<string> = [];
+	if (log_intro) {
+		logged.unshift(
+			`\n\n${st('gray', 'Run a task:')} gro [name]`,
+			`\n${st('gray', 'View help:')}  gro [name] --help`,
+		);
+	}
+
+	for (const [root_dir, resolved_input_files] of resolved_input_files_by_root_dir) {
+		const dir_label = print_path(root_dir);
+		if (!resolved_input_files.length) {
+			log.info(`No tasks found in ${dir_label}.`);
+			continue;
+		}
+		logged.push(
+			`${log_intro ? '\n\n' : ''}${resolved_input_files.length} task${plural(
+				resolved_input_files.length,
+			)} in ${dir_label}:\n`,
+		);
+		const longest_task_name = to_max_length(modules, (m) => m.name);
+		for (const resolved_input_file of resolved_input_files) {
+			const meta = modules.find((m) => m.id === resolved_input_file.id)!;
+			logged.push(
+				'\n' + st('cyan', meta.name.padEnd(longest_task_name)),
+				'  ',
+				meta.mod.task.summary ?? '',
+			);
+		}
+	}
+	log[log_intro ? 'info' : 'raw'](logged.join('') + '\n');
+};
+
+export const log_error_reasons = (log: Logger, reasons: Array<string>): void => {
+	for (const reason of reasons) {
+		log.error(st('red', reason));
+	}
+};
+
+const ARGS_PROPERTY_NAME = '[...args]';
+
+export const log_task_help = (log: Logger, meta: TaskModuleMeta): void => {
+	const {
+		name,
+		mod: {task},
+	} = meta;
+	const logged: Array<string> = [];
+	logged.push(
+		st('cyan', name),
+		'help',
+		st('cyan', `\n\ngro ${name}`) + `: ${task.summary ?? '(no summary available)'}\n`,
+	);
+	if (task.Args) {
+		const properties = to_arg_properties(task.Args, meta, log);
+		// TODO hacky padding for some quick and dirty tables
+		const longest_task_name = Math.max(
+			ARGS_PROPERTY_NAME.length,
+			to_max_length(properties, (p) => p.name),
+		);
+		const longest_type = to_max_length(properties, (p) => p.schema.type);
+		const longest_default = to_max_length(properties, (p) => print_value(p.schema.default));
+		for (const property of properties) {
+			const name = property.name === '_' ? ARGS_PROPERTY_NAME : property.name;
+			logged.push(
+				`\n${st('green', name.padEnd(longest_task_name))} `,
+				st('gray', property.schema.type.padEnd(longest_type)) + ' ',
+				print_value(property.schema.default).padEnd(longest_default) + ' ',
+				property.schema.description || '(no description available)',
+			);
+		}
+		if (!properties.length) {
+			logged.push('\n' + st('gray', 'this task has no args'));
+		}
+	}
+	log.info(...logged, '\n');
+};
+
+// TODO rework all of this
+// The following Zod helpers only need to support single-depth schemas for CLI args,
+// but there's generic recursion to handle things like `ZodOptional` and `ZodDefault`.
+
+interface ArgSchemaProperty {
+	name: string;
+	schema: ArgSchema;
+}
+
+// TODO this blocks many usecases like unions, and it's only implemented for CLI arg types, need better support for arbitrary schemas
+const to_arg_properties = (
+	schema: z.ZodType,
+	meta: TaskModuleMeta,
+	log: Logger,
+): Array<ArgSchemaProperty> => {
+	const {def} = schema;
+
+	// TODO overly restrictive, support optional objects and/or unions?
+	if (!('shape' in def)) {
+		log.error(`Expected Args for task "${meta.name}" to be an object schema but got ${def.type}`);
+		return [];
+	}
+	const shape = (def as z.core.$ZodObjectDef).shape;
+
+	const properties: Array<ArgSchemaProperty> = [];
+	for (const name in shape) {
+		if ('no-' + name in shape) continue;
+		const s = shape[name] as z.ZodType;
+		const schema: ArgSchema = {
+			type: to_args_schema_type(s),
+			description: to_args_schema_description(s) || '',
+			default: to_args_schema_default(s),
+		};
+		properties.push({name, schema});
+	}
+	return properties;
+};
+
+const to_max_length = <T>(items: Array<T>, toString: (item: T) => string) =>
+	items.reduce((max, m) => Math.max(toString(m).length, max), 0);
+
+const to_args_schema_type = (schema: z.ZodType): ArgSchema['type'] => {
+	const {def} = schema._zod;
+	switch (def.type) {
+		case 'string':
+			return 'string';
+		case 'number':
+			return 'number';
+		case 'int':
+			return 'int';
+		case 'boolean':
+			return 'boolean';
+		case 'bigint':
+			return 'bigint';
+		case 'symbol':
+			return 'symbol';
+		case 'null':
+			return 'null';
+		case 'undefined':
+			return 'undefined';
+		case 'void':
+			return 'void';
+		case 'never':
+			return 'never';
+		case 'any':
+			return 'any';
+		case 'unknown':
+			return 'unknown';
+		case 'date':
+			return 'date';
+		case 'object':
+			return 'object';
+		case 'record':
+			return 'record';
+		case 'file':
+			return 'file';
+		case 'array':
+			// TODO other types, only handling a subset of CLI arg cases
+			return 'Array<string>';
+		case 'tuple':
+			return 'tuple';
+		case 'union':
+			// TODO fix, this is a hacky way to handle unions for CLI args
+			return 'string | Array<string>';
+		case 'intersection':
+			return 'intersection';
+		case 'map':
+			return 'map';
+		case 'set':
+			return 'set';
+		case 'enum':
+			return (schema as unknown as {options: Array<string>}).options
+				.map((v) => `'${v}'`)
+				.join(' | ');
+		case 'literal':
+			return (def as unknown as {values: Array<any>}).values.map((v) => print_value(v)).join(' | ');
+		case 'nullable': {
+			const subschema = to_subschema(def);
+			return subschema ? to_args_schema_type(subschema) + ' | null' : 'nullable';
+		}
+		case 'optional': {
+			const subschema = to_subschema(def);
+			return subschema ? to_args_schema_type(subschema) + ' | undefined' : 'optional';
+		}
+		case 'success':
+			return 'success';
+		case 'catch':
+			return 'catch';
+		case 'nan':
+			return 'NaN';
+		case 'readonly':
+			return 'readonly';
+		case 'template_literal':
+			return 'template_literal';
+		case 'promise':
+			return 'promise';
+		case 'lazy':
+			return 'lazy';
+		case 'custom':
+			return 'custom';
+		// Unwrap these:
+		// case 'nonoptional':
+		// case 'transform':
+		// case 'default':
+		// case 'prefault':
+		// case 'pipe':
+		default: {
+			const subschema = to_subschema(def);
+			return subschema ? to_args_schema_type(subschema) : def.type;
+		}
+	}
+};
+
+const to_args_schema_description = (schema: z.ZodType): string | null => {
+	const meta = schema.meta();
+	if (meta?.description) {
+		return meta.description;
+	}
+	const subschema = to_subschema(schema.def);
+	if (subschema) {
+		return to_args_schema_description(subschema);
+	}
+	return null;
+};
+
+const to_args_schema_default = (schema: z.ZodType): any => {
+	const {def} = schema._zod;
+	if ('defaultValue' in def) {
+		return def.defaultValue;
+	}
+	const subschema = to_subschema(def);
+	if (subschema) {
+		return to_args_schema_default(subschema);
+	}
+};
+
+const to_subschema = (def: z.core.$ZodTypeDef): z.ZodType | undefined => {
+	if ('innerType' in def) {
+		return def.innerType as any;
+	} else if ('in' in def) {
+		return def.in as any;
+	} else if ('schema' in def) {
+		return def.schema as any;
+	}
+	return undefined;
+};

package/src/lib/test.task.ts

@@ -0,0 +1,63 @@
+import {args_serialize} from '@fuzdev/fuz_util/args.js';
+import {spawn_result_to_message} from '@fuzdev/fuz_util/process.js';
+import {spawn_cli} from '@fuzdev/gro/cli.js';
+import {z} from 'zod';
+
+import {to_implicit_forwarded_args} from './args.ts';
+import {find_cli} from './cli.ts';
+import {VITEST_CLI} from './constants.ts';
+import {package_json_has_dependency, package_json_load} from './package_json.ts';
+import {paths} from './paths.ts';
+import {TaskError, type Task} from './task.ts';
+
+/** @nodocs */
+export const Args = z.strictObject({
+	_: z.array(z.string()).meta({description: 'file patterns to filter tests'}).default(['.test.']),
+	dir: z.string().meta({description: 'working directory for tests'}).default(paths.source),
+	fail_without_tests: z
+		.boolean()
+		.meta({description: 'opt out of `passWithNoTests`'})
+		.default(false),
+	t: z
+		.string()
+		.meta({description: 'search pattern for test names, same as vitest -t and --testNamePattern'})
+		.optional(),
+});
+export type Args = z.infer<typeof Args>;
+
+/** @nodocs */
+export const task: Task<Args> = {
+	summary: 'run tests with vitest',
+	Args,
+	run: async ({args}): Promise<void> => {
+		const {_: patterns, dir, fail_without_tests, t} = args;
+
+		const package_json = await package_json_load();
+		if (!package_json_has_dependency(VITEST_CLI, package_json)) {
+			throw new TaskError('no test runner found, install vitest');
+		}
+
+		if (!(await find_cli(VITEST_CLI))) {
+			throw new TaskError('vitest is a dependency but not installed; run `npm i`?');
+		}
+
+		const vitest_args = ['run', ...patterns];
+		if (dir) {
+			vitest_args.push('--dir', dir);
+		}
+		if (!fail_without_tests) {
+			vitest_args.push('--passWithNoTests');
+		}
+		if (t) {
+			vitest_args.push('-t', t);
+		}
+		vitest_args.push(...args_serialize(to_implicit_forwarded_args(VITEST_CLI)));
+
+		const spawned = await spawn_cli(VITEST_CLI, vitest_args);
+		if (!spawned?.ok) {
+			throw new TaskError(
+				`vitest failed: ${spawned ? spawn_result_to_message(spawned) : 'unknown error'}`,
+			);
+		}
+	},
+};

package/src/lib/typecheck.task.ts

@@ -0,0 +1,81 @@
+import {args_serialize} from '@fuzdev/fuz_util/args.js';
+import {print_spawn_result} from '@fuzdev/fuz_util/process.js';
+import {z} from 'zod';
+
+import {to_forwarded_args} from './args.ts';
+import {configure_colored_output_with_path_replacement} from './child_process_logging.ts';
+import {find_cli, spawn_cli, spawn_cli_process} from './cli.ts';
+import {SVELTE_CHECK_CLI} from './constants.ts';
+import {paths} from './paths.ts';
+import {sveltekit_sync_if_available} from './sveltekit_helpers.ts';
+import {TaskError, type Task} from './task.ts';
+
+/** @nodocs */
+export const Args = z.strictObject({
+	svelte_check_cli: z
+		.string()
+		.meta({description: 'the svelte-check CLI to use'})
+		.default(SVELTE_CHECK_CLI),
+	typescript_cli: z
+		.string()
+		.meta({description: 'the TypeScript CLI to use as a fallback to svelte-check'})
+		.default('tsc'),
+	path_replacement: z
+		.string()
+		.meta({description: 'replacement string for current working directory in output'})
+		.default('.'),
+	cwd: z.string().meta({description: 'current working directory'}).default(paths.root),
+});
+export type Args = z.infer<typeof Args>;
+
+/** @nodocs */
+export const task: Task<Args> = {
+	summary: 'run svelte-check or tsc on the project without emitting any files',
+	Args,
+	run: async ({args, log}): Promise<void> => {
+		const {svelte_check_cli, typescript_cli, path_replacement, cwd} = args;
+
+		await sveltekit_sync_if_available();
+
+		// Prefer svelte-check if available.
+		const found_svelte_check_cli = await find_cli(svelte_check_cli);
+		if (found_svelte_check_cli) {
+			const serialized = args_serialize(to_forwarded_args(svelte_check_cli));
+			const spawned = await spawn_cli_process(found_svelte_check_cli, serialized, undefined, {
+				stdio: ['inherit', 'pipe', 'pipe'],
+				env: {...process.env, FORCE_COLOR: '1'}, // Needed for colors (maybe make an option)
+			});
+
+			const svelte_check_process = spawned?.child;
+			if (svelte_check_process) {
+				// Configure process output with path replacement while preserving colors
+				configure_colored_output_with_path_replacement(svelte_check_process, path_replacement, cwd);
+
+				const svelte_check_result = await spawned.closed;
+
+				if (!svelte_check_result.ok) {
+					throw new TaskError(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
+				}
+			}
+
+			return;
+		}
+
+		// Fall back to tsc.
+		const found_typescript_cli = await find_cli(typescript_cli);
+		if (found_typescript_cli) {
+			const forwarded = to_forwarded_args(typescript_cli);
+			if (!forwarded.noEmit) forwarded.noEmit = true;
+			const serialized = args_serialize(forwarded);
+			const svelte_check_result = await spawn_cli(found_typescript_cli, serialized, log);
+			if (!svelte_check_result?.ok) {
+				throw new TaskError(`Failed to typecheck. ${print_spawn_result(svelte_check_result!)}`);
+			}
+			return;
+		}
+
+		throw new TaskError(
+			`Failed to typecheck because neither \`${svelte_check_cli}\` nor \`${typescript_cli}\` was found`,
+		);
+	},
+};

package/src/lib/upgrade.task.ts

@@ -0,0 +1,148 @@
+import {args_serialize} from '@fuzdev/fuz_util/args.js';
+import {GitOrigin, git_pull} from '@fuzdev/fuz_util/git.js';
+import {spawn} from '@fuzdev/fuz_util/process.js';
+import {rm} from 'node:fs/promises';
+import {z} from 'zod';
+
+import {to_forwarded_args} from './args.ts';
+import {spawn_cli} from './cli.ts';
+import {NODE_MODULES_DIRNAME} from './constants.ts';
+import {
+	package_json_extract_dependencies,
+	package_json_load,
+	type PackageJsonDep,
+} from './package_json.ts';
+import {TaskError, type Task} from './task.ts';
+
+/** @nodocs */
+export const Args = z.strictObject({
+	_: z
+		.array(z.string())
+		.meta({description: 'names of deps to exclude from the upgrade'})
+		.default([]),
+	only: z
+		.union([z.string(), z.array(z.string())])
+		.meta({
+			description: 'names of deps to include in the upgrade',
+		})
+		.default([])
+		.transform((v) => (Array.isArray(v) ? v : [v])),
+	origin: GitOrigin.describe('git origin to deploy to').default('origin'),
+	force: z.boolean().meta({description: 'if true, print out the planned upgrades'}).default(false),
+	pull: z.boolean().meta({description: 'dual of no-pull'}).default(true),
+	'no-pull': z.boolean().meta({description: 'opt out of git pull'}).default(false),
+	delete_node_modules: z
+		.boolean()
+		.meta({description: 'if true, deletes node_modules before upgrading'})
+		.default(false),
+	node_modules_path: z // TODO maybe configured globally instead
+		.string()
+		.meta({description: 'path to modules directory to delete'})
+		.default(NODE_MODULES_DIRNAME),
+	delete_lockfile: z
+		.boolean()
+		.meta({description: 'if true, deletes the lockfile before upgrading'})
+		.default(false),
+	lockfile_path: z
+		.string()
+		.meta({description: 'path to the lockfile to delete'})
+		.default('package-lock.json'),
+	dry: z.boolean().meta({description: 'if true, print out the planned upgrades'}).default(false),
+});
+export type Args = z.infer<typeof Args>;
+
+/** @nodocs */
+export const task: Task<Args> = {
+	summary: 'upgrade deps',
+	Args,
+	run: async ({args, log, config}): Promise<void> => {
+		const {
+			_,
+			only,
+			origin,
+			force,
+			pull,
+			delete_node_modules,
+			node_modules_path,
+			delete_lockfile,
+			lockfile_path,
+			dry,
+		} = args;
+
+		if (_.length && only.length) {
+			throw new TaskError('Cannot call `gro upgrade` with both rest args and --only.');
+		}
+
+		// TODO maybe a different task that pulls and does other things, like `gro ready`
+		if (pull) {
+			await git_pull(origin);
+		}
+
+		if (delete_node_modules) {
+			log.info(`deleting node_modules at `, node_modules_path);
+			await rm(node_modules_path, {recursive: true, force: true});
+		}
+
+		if (delete_lockfile) {
+			log.info(`deleting lockfile at`, lockfile_path);
+			await rm(lockfile_path, {force: true});
+		}
+
+		const package_json = await package_json_load();
+
+		const all_deps = package_json_extract_dependencies(package_json);
+
+		const deps = only.length
+			? all_deps.filter((d) => only.includes(d.name))
+			: all_deps.filter((d) => !_.includes(d.name));
+
+		if (only.length && only.length !== deps.length) {
+			throw new TaskError(
+				`Some deps to upgrade were not found: ${only.filter((o) => !deps.find((d) => d.name === o)).join(', ')}`,
+			);
+		}
+
+		const upgrade_items = to_upgrade_items(deps);
+
+		log.info(`upgrading:`, upgrade_items.join(' '));
+
+		const install_args = ['install'].concat(upgrade_items);
+		if (dry) {
+			install_args.push('--dry-run');
+			log.info(`deps`, deps);
+		}
+		if (force) {
+			install_args.push('--force');
+		}
+		install_args.push(...args_serialize(to_forwarded_args(config.pm_cli)));
+		await spawn(config.pm_cli, install_args);
+
+		// TODO @many this relies on npm behavior that changed in v11
+		// If we deleted the lockfile or node modules, `npm install` again
+		// to fix a recurring npm bug getting the lockfile to its final state.
+		if (!dry && (delete_node_modules || delete_lockfile)) {
+			log.info(`installing again to fix npm lockfile bugs`);
+			await spawn(config.pm_cli, ['install']);
+		}
+
+		// Sync in a new process to pick up any changes after installing, avoiding some errors.
+		await spawn_cli('gro', ['sync']); // don't install because we do above
+	},
+};
+
+const EXACT_VERSION_MATCHER = /^..*@.+/;
+const CUSTOM_TAG_MATCHER = /^[\^~><=]*.+-(.+)/;
+
+// TODO hacky and limited
+// TODO probably want to pass through exact deps as well, e.g. @foo/bar@1
+const to_upgrade_items = (deps: Array<PackageJsonDep>): Array<string> =>
+	deps.map((dep) => {
+		if (EXACT_VERSION_MATCHER.test(dep.name)) {
+			return dep.name;
+		}
+		const custom_tag_matches = CUSTOM_TAG_MATCHER.exec(dep.version);
+		if (custom_tag_matches) {
+			return dep.name + '@' + custom_tag_matches[1]!.split('.')[0]; // I tried adding `\.?` to the end but doesn't work and I'm being lazy so I'm just splitting
+		}
+		return dep.name + '@latest';
+	});

package/src/lib/watch_dir.ts

@@ -0,0 +1,115 @@
+import {watch, type ChokidarOptions, type FSWatcher, type Matcher} from 'chokidar';
+import {relative} from 'node:path';
+import {statSync} from 'node:fs';
+import {create_deferred, type Deferred} from '@fuzdev/fuz_util/async.js';
+import type {PathFilter} from '@fuzdev/fuz_util/path.js';
+import {EMPTY_OBJECT} from '@fuzdev/fuz_util/object.js';
+
+const TMP_FILE_PATTERN = /\.tmp\./;
+
+// TODO pretty hacky
+
+export interface WatchNodeFs {
+	init: () => Promise<void>;
+	close: () => Promise<void>;
+}
+
+export interface WatcherChange {
+	type: WatcherChangeType;
+	path: string;
+	is_directory: boolean;
+}
+export type WatcherChangeType = 'add' | 'update' | 'delete';
+export type WatcherChangeCallback = (change: WatcherChange) => void;
+
+export interface WatchDirOptions {
+	dir: string;
+	on_change: WatcherChangeCallback;
+	filter?: PathFilter | null | undefined;
+	chokidar?: ChokidarOptions;
+	/**
+	 * When `false`, returns the `path` relative to `dir`.
+	 * @default true
+	 */
+	absolute?: boolean;
+	/**
+	 * Pattern to ignore files, merged into `chokidar.ignored` if also provided.
+	 * - `undefined` (default) ignores files matching `.tmp.` pattern
+	 * - `null` sets no default ignore pattern
+	 * - or some custom pattern
+	 */
+	ignored?: Matcher | null;
+}
+
+/**
+ * Watch for changes on the filesystem using chokidar.
+ */
+export const watch_dir = ({
+	dir,
+	on_change,
+	filter,
+	absolute = true,
+	chokidar,
+	ignored = TMP_FILE_PATTERN,
+}: WatchDirOptions): WatchNodeFs => {
+	let watcher: FSWatcher | undefined;
+	let initing: Deferred<void> | undefined;
+
+	return {
+		init: async () => {
+			if (initing) return initing.promise;
+			initing = create_deferred();
+			watcher = watch(dir, resolve_chokidar_options(chokidar, ignored));
+			watcher.on('add', (path) => {
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, false)) return;
+				on_change({type: 'add', path: final_path, is_directory: false});
+			});
+			watcher.on('addDir', (path) => {
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, true)) return;
+				on_change({type: 'add', path: final_path, is_directory: true});
+			});
+			watcher.on('change', (path, s) => {
+				const stats = s ?? statSync(path);
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, stats.isDirectory())) {
+					return;
+				}
+				on_change({type: 'update', path: final_path, is_directory: stats.isDirectory()});
+			});
+			watcher.on('unlink', (path) => {
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, false)) return;
+				on_change({type: 'delete', path: final_path, is_directory: false});
+			});
+			watcher.on('unlinkDir', (path) => {
+				const final_path = absolute ? path : relative(dir, path);
+				if (filter && !filter(final_path, true)) return;
+				on_change({type: 'delete', path: final_path, is_directory: true});
+			});
+			// wait until ready
+			watcher.once('ready', () => initing?.resolve());
+			await initing.promise;
+		},
+		close: async () => {
+			initing = undefined;
+			if (!watcher) return;
+			await watcher.close();
+		},
+	};
+};
+
+const resolve_chokidar_options = (
+	options: ChokidarOptions | undefined,
+	ignored: Matcher | null,
+): ChokidarOptions | undefined => {
+	if (ignored === null) return options;
+
+	const {ignored: i, ...rest} = options ?? EMPTY_OBJECT;
+
+	const resolved_ignored =
+		i === undefined ? ignored : Array.isArray(i) ? [...i, ignored] : [i, ignored];
+
+	return {...rest, ignored: resolved_ignored};
+};