@ryanatkn/gro 0.124.0 → 0.125.0

package/README.md

@@ -83,7 +83,7 @@ as a dev dependency:
 
 ```bash
 npm i -D @ryanatkn/gro
-npx gro
+npx gro # note the package is namespaced, don't install `gro`
 ```
 
 It's handy to install globally too:

package/dist/args.js

@@ -1,4 +1,4 @@
-import { magenta } from 'kleur/colors';
+import { gray, magenta } from 'kleur/colors';
 import mri from 'mri';
 /**
  * Parses user input args with a Zod schema.
@@ -129,4 +129,4 @@ export const to_forwarded_args_by_command = (raw_rest_args = to_raw_rest_args())
     }
     return forwarded_args_by_command;
 };
-export const print_command_args = (serialized_args) => magenta('running command: ') + serialized_args.join(' ');
+export const print_command_args = (serialized_args) => gray('[') + magenta('running command') + gray(']') + ' ' + serialized_args.join(' ');

package/dist/changeset.task.d.ts

@@ -1,7 +1,5 @@
 import { z } from 'zod';
 import { type Task } from './task.js';
-export declare const Changeset_Bump: z.ZodEnum<["patch", "minor", "major"]>;
-export type Changeset_Bump = z.infer<typeof Changeset_Bump>;
 export declare const Args: z.ZodObject<{
     /**
      * The optional rest args get joined with a space to form the `message`.
@@ -15,6 +13,7 @@ export declare const Args: z.ZodObject<{
     install: z.ZodDefault<z.ZodBoolean>;
     'no-install': z.ZodDefault<z.ZodBoolean>;
     origin: z.ZodDefault<z.ZodBranded<z.ZodString, "Git_Origin">>;
+    changeset_cli: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     _: string[];
     dir: string;
@@ -24,6 +23,7 @@ export declare const Args: z.ZodObject<{
     minor: boolean;
     major: boolean;
     changelog: string;
+    changeset_cli: string;
     access?: "public" | "restricted" | undefined;
 }, {
     _?: string[] | undefined;
@@ -35,6 +35,7 @@ export declare const Args: z.ZodObject<{
     major?: boolean | undefined;
     access?: "public" | "restricted" | undefined;
     changelog?: string | undefined;
+    changeset_cli?: string | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 /**

package/dist/changeset.task.js

@@ -9,10 +9,7 @@ import { load_package_json } from './package_json.js';
 import { find_cli, spawn_cli } from './cli.js';
 import { Git_Origin, git_check_fully_staged_workspace, git_push_to_create } from './git.js';
 import { has_sveltekit_library } from './sveltekit_helpers.js';
-const RESTRICTED_ACCESS = 'restricted';
-const PUBLIC_ACCESS = 'public';
-const CHANGESET_DIR = '.changeset';
-export const Changeset_Bump = z.enum(['patch', 'minor', 'major']);
+import { CHANGESET_CLI, CHANGESET_DIR, Changeset_Access, Changeset_Bump, CHANGESET_PUBLIC_ACCESS, CHANGESET_RESTRICTED_ACCESS, } from './changeset_helpers.js';
 export const Args = z
     .object({
     /**
@@ -22,11 +19,7 @@ export const Args = z
     minor: z.boolean({ description: 'bump the minor version' }).default(false),
     major: z.boolean({ description: 'bump the major version' }).default(false),
     dir: z.string({ description: 'changeset dir' }).default(CHANGESET_DIR),
-    access: z
-        .enum([RESTRICTED_ACCESS, PUBLIC_ACCESS], {
-        description: `changeset 'access' config value, the default depends on package.json#private`,
-    })
-        .optional(),
+    access: Changeset_Access.describe("changeset 'access' config value, the default depends on package.json#private").optional(),
     changelog: z
         .string({ description: 'changeset "changelog" config value' })
         .default('@changesets/changelog-git'),
@@ -35,6 +28,7 @@ export const Args = z
         .boolean({ description: 'opt out of npm installing the changelog package' })
         .default(false),
     origin: Git_Origin.describe('git origin to deploy to').default('origin'),
+    changeset_cli: z.string({ description: 'the changeset CLI to use' }).default(CHANGESET_CLI),
 })
     .strict();
 /**
@@ -50,14 +44,15 @@ export const task = {
     summary: 'call changeset with gro patterns',
     Args,
     run: async (ctx) => {
-        const { invoke_task, args: { _, minor, major, dir, access: access_arg, changelog, install, origin }, log, } = ctx;
+        const { invoke_task, args: { _, minor, major, dir, access: access_arg, changelog, install, origin, changeset_cli }, log, } = ctx;
         const message = _.join(' ');
         if (!message && (minor || major))
             throw new Task_Error('cannot bump version without a message');
         if (minor && major)
             throw new Task_Error('cannot bump both minor and major');
         const bump = minor ? 'minor' : major ? 'major' : 'patch';
-        if (!(await find_cli('changeset'))) {
+        const found_changeset_cli = await find_cli(changeset_cli);
+        if (!found_changeset_cli) {
             throw new Task_Error('changeset command not found: install @changesets/cli locally or globally');
         }
         const package_json = await load_package_json();
@@ -68,11 +63,11 @@ export const task = {
         const path = join(dir, 'config.json');
         const inited = existsSync(path);
         if (!inited) {
-            await spawn_cli('changeset', ['init']);
-            const access = access_arg ?? package_json.private ? RESTRICTED_ACCESS : PUBLIC_ACCESS;
-            const access_color = access === RESTRICTED_ACCESS ? blue : red;
+            await spawn_cli(found_changeset_cli, ['init'], log);
+            const access = access_arg ?? package_json.private ? CHANGESET_RESTRICTED_ACCESS : CHANGESET_PUBLIC_ACCESS;
+            const access_color = access === CHANGESET_RESTRICTED_ACCESS ? blue : red;
             log.info('initing changeset with ' + access_color(access) + ' access');
-            if (access !== RESTRICTED_ACCESS) {
+            if (access !== CHANGESET_RESTRICTED_ACCESS) {
                 await update_changeset_config(path, (config) => {
                     const updated = { ...config };
                     updated.access = access;
@@ -90,7 +85,7 @@ export const task = {
         if (message) {
             // TODO see the helper below, simplify this to CLI flags when support is added to Changesets
             const changeset_adder = await create_changeset_adder(package_json.name, dir, message, bump);
-            await spawn_cli('changeset', ['add', '--empty']);
+            await spawn_cli(found_changeset_cli, ['add', '--empty'], log);
             await changeset_adder();
             if (!(await git_check_fully_staged_workspace())) {
                 await spawn('git', ['commit', '-m', message]);
@@ -98,7 +93,7 @@ export const task = {
             }
         }
         else {
-            await spawn_cli('changeset');
+            await spawn_cli(found_changeset_cli, [], log);
             await spawn('git', ['add', dir]);
         }
     },

package/dist/changeset_helpers.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const CHANGESET_RESTRICTED_ACCESS = "restricted";
+export declare const CHANGESET_PUBLIC_ACCESS = "public";
+export declare const Changeset_Access: z.ZodEnum<["restricted", "public"]>;
+export declare const CHANGESET_CLI = "changeset";
+export declare const CHANGESET_DIR = ".changeset";
+export declare const Changeset_Bump: z.ZodEnum<["patch", "minor", "major"]>;
+export type Changeset_Bump = z.infer<typeof Changeset_Bump>;

package/dist/changeset_helpers.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const CHANGESET_RESTRICTED_ACCESS = 'restricted';
+export const CHANGESET_PUBLIC_ACCESS = 'public';
+export const Changeset_Access = z.enum([CHANGESET_RESTRICTED_ACCESS, CHANGESET_PUBLIC_ACCESS]);
+export const CHANGESET_CLI = 'changeset';
+export const CHANGESET_DIR = '.changeset';
+export const Changeset_Bump = z.enum(['patch', 'minor', 'major']);

package/dist/cli.d.ts

@@ -1,10 +1,31 @@
 import type { SpawnOptions } from 'node:child_process';
-import { type Spawn_Result } from '@ryanatkn/belt/process.js';
+import { type Spawn_Result, type Spawned_Process } from '@ryanatkn/belt/process.js';
+import type { Path_Id } from './path.js';
+export type Cli = {
+    kind: 'local';
+    name: string;
+    id: Path_Id;
+} | {
+    kind: 'global';
+    name: string;
+    id: Path_Id;
+};
 /**
- * Looks for the CLI `name`, first local to the cwd and then globally.
+ * Searches the filesystem for the CLI `name`, first local to the cwd and then globally.
+ * @returns `null` if not found locally or globally
  */
-export declare const find_cli: (name: string) => Promise<"local" | "global" | null>;
+export declare const find_cli: (name: string, cwd?: string | URL) => Promise<Cli | null>;
 /**
- * Calls the CLI `name` if available, first local to the cwd and then globally.
+ * Spawns a CLI if available using Belt's `spawn`.
+ * If a string is provided for `name_or_cli`, it checks first local to the cwd and then globally.
+ * @returns `undefined` if no CLI is found, or the spawn result
  */
-export declare const spawn_cli: (name: string, args?: any[], options?: SpawnOptions | undefined) => Promise<Spawn_Result | undefined>;
+export declare const spawn_cli: (name_or_cli: string | Cli, args?: string[], log?: any, options?: SpawnOptions | undefined) => Promise<Spawn_Result | undefined>;
+/**
+ * Spawns a CLI if available using Belt's `spawn_process`.
+ * If a string is provided for `name_or_cli`, it checks first local to the cwd and then globally.
+ * @returns `undefined` if no CLI is found, or the spawn result
+ */
+export declare const spawn_cli_process: (name_or_cli: string | Cli, args?: string[], log?: any, options?: SpawnOptions | undefined) => Promise<Spawned_Process | undefined>;
+export declare const resolve_cli: (name_or_cli: string | Cli, args: string[] | undefined, cwd: string | URL | undefined, log?: any) => Promise<Cli | undefined>;
+export declare const to_cli_name: (cli: string | Cli) => string;

package/dist/cli.js

@@ -1,25 +1,61 @@
-import { spawn, spawn_out } from '@ryanatkn/belt/process.js';
+import { spawn, spawn_out, spawn_process, } from '@ryanatkn/belt/process.js';
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { NODE_MODULES_DIRNAME } from './path_constants.js';
+import { print_command_args } from './args.js';
 /**
- * Looks for the CLI `name`, first local to the cwd and then globally.
+ * Searches the filesystem for the CLI `name`, first local to the cwd and then globally.
+ * @returns `null` if not found locally or globally
  */
-export const find_cli = async (name) => {
-    if (existsSync(join(NODE_MODULES_DIRNAME, `.bin/${name}`))) {
-        return 'local';
+export const find_cli = async (name, cwd = process.cwd()) => {
+    const final_cwd = typeof cwd === 'string' ? cwd : fileURLToPath(cwd);
+    const local_id = join(final_cwd, NODE_MODULES_DIRNAME, `.bin/${name}`);
+    if (existsSync(local_id)) {
+        return { name, id: local_id, kind: 'local' };
     }
     const { stdout } = await spawn_out('which', [name]);
-    return stdout === null ? null : 'global';
+    const global_id = stdout?.trim();
+    if (!global_id)
+        return null;
+    return { name, id: global_id, kind: 'global' };
 };
 /**
- * Calls the CLI `name` if available, first local to the cwd and then globally.
+ * Spawns a CLI if available using Belt's `spawn`.
+ * If a string is provided for `name_or_cli`, it checks first local to the cwd and then globally.
+ * @returns `undefined` if no CLI is found, or the spawn result
  */
-export const spawn_cli = async (name, args = [], options) => {
-    const found = await find_cli(name);
-    if (!found)
+export const spawn_cli = async (name_or_cli, args = [], log, options) => {
+    const cli = await resolve_cli(name_or_cli, args, options?.cwd, log);
+    if (!cli)
         return;
-    const command = found === 'local' ? 'npx' : name;
-    const final_args = found === 'local' ? [name].concat(args) : args;
-    return spawn(command, final_args, options);
+    return spawn(cli.id, args, options);
 };
+/**
+ * Spawns a CLI if available using Belt's `spawn_process`.
+ * If a string is provided for `name_or_cli`, it checks first local to the cwd and then globally.
+ * @returns `undefined` if no CLI is found, or the spawn result
+ */
+export const spawn_cli_process = async (name_or_cli, args = [], log, options) => {
+    const cli = await resolve_cli(name_or_cli, args, options?.cwd, log);
+    if (!cli)
+        return;
+    return spawn_process(cli.id, args, options);
+};
+export const resolve_cli = async (name_or_cli, args = [], cwd, log) => {
+    let final_cli;
+    if (typeof name_or_cli === 'string') {
+        const found = await find_cli(name_or_cli, cwd);
+        if (!found)
+            return;
+        final_cli = found;
+    }
+    else {
+        final_cli = name_or_cli;
+    }
+    if (log) {
+        log.info(print_command_args([final_cli.name].concat(args)));
+    }
+    return final_cli;
+};
+export const to_cli_name = (cli) => typeof cli === 'string' ? cli : cli.name;

package/dist/config.d.ts

@@ -1,7 +1,15 @@
 import type { Create_Config_Plugins } from './plugin.js';
 import type { Map_Package_Json } from './package_json.js';
-import type { Path_Filter } from './path.js';
+import type { Path_Filter, Path_Id } from './path.js';
+/**
+ * The config that users can extend via `gro.config.ts`.
+ * This is exposed to users in places like tasks and genfiles.
+ * @see https://github.com/ryanatkn/gro/blob/main/src/lib/docs/config.md
+ */
 export interface Gro_Config {
+    /**
+     * @see https://github.com/ryanatkn/gro/blob/main/src/lib/docs/plugin.md
+     */
     plugins: Create_Config_Plugins;
     /**
      * Maps the project's `package.json` before writing it to the filesystem.
@@ -13,15 +21,26 @@ export interface Gro_Config {
      * The root directories to search for tasks given implicit relative input paths.
      * Defaults to `./src/lib`, then the cwd, then the Gro package dist.
      */
-    task_root_dirs: string[];
+    task_root_dirs: Path_Id[];
     /**
      * When searching the filsystem for tasks and genfiles,
      * directories and files are included if they pass all of these filters.
      */
-    search_filters: Path_Filter | Path_Filter[] | null;
+    search_filters: Path_Filter[];
+}
+/**
+ * The relaxed variant of `Gro_Config` that users can provide via `gro.config.ts`.
+ * Superset of `Gro_Config`.
+ * @see https://github.com/ryanatkn/gro/blob/main/src/lib/docs/config.md
+ */
+export interface Raw_Gro_Config {
+    plugins?: Create_Config_Plugins;
+    map_package_json?: Map_Package_Json | null;
+    task_root_dirs?: string[];
+    search_filters?: Path_Filter | Path_Filter[] | null;
 }
 export interface Create_Gro_Config {
-    (base_config: Gro_Config): Gro_Config | Promise<Gro_Config>;
+    (base_config: Gro_Config): Raw_Gro_Config | Promise<Raw_Gro_Config>;
 }
 export declare const create_empty_config: () => Gro_Config;
 /**
@@ -32,8 +51,13 @@ export declare const create_empty_config: () => Gro_Config;
  */
 export declare const DEFAULT_SEARCH_EXCLUDER: RegExp;
 export declare const DEFAULT_EXPORTS_EXCLUDER: RegExp;
+/**
+ * Transforms a `Raw_Gro_Config` to the more strict `Gro_Config`.
+ * This allows users to provide a more relaxed config.
+ */
+export declare const normalize_config: (raw_config: Raw_Gro_Config) => Gro_Config;
 export interface Gro_Config_Module {
-    readonly default: Gro_Config | Create_Gro_Config;
+    readonly default: Raw_Gro_Config | Create_Gro_Config;
 }
 export declare const load_config: (dir?: string) => Promise<Gro_Config>;
 export declare const validate_config_module: (config_module: any, config_path: string) => asserts config_module is Gro_Config_Module;

package/dist/config.js

@@ -5,9 +5,9 @@ import { GRO_CONFIG_PATH, NODE_MODULES_DIRNAME, SERVER_DIST_PATH, SVELTEKIT_BUIL
 import create_default_config from './gro.config.default.js';
 export const create_empty_config = () => ({
     plugins: () => [],
-    // TODO maybe disable if no SvelteKit `lib` directory? or other detection to improve defaults
     map_package_json: default_map_package_json,
     task_root_dirs: [
+        // TODO maybe disable if no SvelteKit `lib` directory? or other detection to improve defaults
         paths.lib,
         IS_THIS_GRO ? null : paths.root,
         IS_THIS_GRO ? null : GRO_DIST_DIR,
@@ -34,28 +34,39 @@ const default_map_package_json = async (package_json) => {
     return package_json;
 };
 export const DEFAULT_EXPORTS_EXCLUDER = /(\.md|\.(test|ignore)\.|\/(test|fixtures|ignore)\/)/u;
+/**
+ * Transforms a `Raw_Gro_Config` to the more strict `Gro_Config`.
+ * This allows users to provide a more relaxed config.
+ */
+export const normalize_config = (raw_config) => {
+    const empty_config = create_empty_config();
+    // All of the raw config properties are optional,
+    // so fall back to the empty values when `undefined`.
+    const { plugins = empty_config.plugins, map_package_json = empty_config.map_package_json, task_root_dirs = empty_config.task_root_dirs, search_filters = empty_config.search_filters, } = raw_config;
+    return {
+        plugins,
+        map_package_json,
+        task_root_dirs: task_root_dirs.map((p) => resolve(p)),
+        search_filters: Array.isArray(search_filters)
+            ? search_filters
+            : search_filters
+                ? [search_filters]
+                : [],
+    };
+};
 export const load_config = async (dir = paths.root) => {
-    const default_config = await create_default_config(create_empty_config());
+    const default_config = normalize_config(await create_default_config(create_empty_config()));
     const config_path = join(dir, GRO_CONFIG_PATH);
-    let config;
-    if (existsSync(config_path)) {
-        const config_module = await import(config_path);
-        validate_config_module(config_module, config_path);
-        config =
-            typeof config_module.default === 'function'
-                ? await config_module.default(default_config)
-                : config_module.default;
-        normalize_config(config);
+    if (!existsSync(config_path)) {
+        // No user config file found, so return the default.
+        return default_config;
     }
-    else {
-        config = default_config;
-    }
-    return config;
-};
-// Mutates `config` with cleaned up values.
-const normalize_config = (config) => {
-    // TODO any validation?
-    config.task_root_dirs = config.task_root_dirs.map((p) => resolve(p));
+    // Import the user's `gro.config.ts`.
+    const config_module = await import(config_path);
+    validate_config_module(config_module, config_path);
+    return normalize_config(typeof config_module.default === 'function'
+        ? await config_module.default(default_config)
+        : config_module.default);
 };
 export const validate_config_module = (config_module, config_path) => {
     const config = config_module.default;

package/dist/deploy.task.js

@@ -16,7 +16,6 @@ import { git_check_clean_workspace, git_checkout, git_local_branch_exists, git_r
 // TODO customize
 const dir = process.cwd();
 const INITIAL_FILE_PATH = '.gitkeep';
-const INITIAL_FILE_CONTENTS = '';
 const DEPLOY_DIR = GRO_DIRNAME + '/deploy';
 const SOURCE_BRANCH = 'main';
 const TARGET_BRANCH = 'deploy';
@@ -143,14 +142,12 @@ export const task = {
             // Create the target branch locally and remotely.
             // This is more complex to avoid churning the cwd.
             await git_clone_locally(origin, source, dir, resolved_deploy_dir);
-            await spawn(`git checkout --orphan ${target} && ` +
-                // TODO there's definitely a better way to do this
-                `git rm -rf . && ` +
-                `echo "${INITIAL_FILE_CONTENTS}" >> ${INITIAL_FILE_PATH} && ` +
-                `git add ${INITIAL_FILE_PATH} && ` +
-                `git commit -m "init"`, [], 
-            // Use `shell: true` because the above is unwieldy with standard command construction
-            { ...target_spawn_options, shell: true });
+            await spawn('git', ['checkout', '--orphan', target], target_spawn_options);
+            // TODO there's definitely a better way to do this
+            await spawn('git', ['rm', '-rf', '.'], target_spawn_options);
+            await spawn('touch', [INITIAL_FILE_PATH], target_spawn_options);
+            await spawn('git', ['add', INITIAL_FILE_PATH], target_spawn_options);
+            await spawn('git', ['commit', '-m', 'init'], target_spawn_options);
             await git_push_to_create(origin, target, target_spawn_options);
             await git_delete_local_branch(source, target_spawn_options);
         }

package/dist/docs/config.md

@@ -38,14 +38,23 @@ The default export of a Gro config is `Gro_Config | Create_Gro_Config`:
 
 ```ts
 export interface Create_Gro_Config {
-	(base_config: Gro_Config): Gro_Config | Promise<Gro_Config>;
+	(base_config: Gro_Config): Raw_Gro_Config | Promise<Raw_Gro_Config>;
 }
 
+// The strict variant that's used internally and exposed to users in tasks and elsewhere.
 export interface Gro_Config {
 	plugins: Create_Config_Plugins;
 	map_package_json: Map_Package_Json | null;
-	task_root_dirs: string[];
-	search_filters: Path_Filter | Path_Filter[] | null;
+	task_root_dirs: Path_Id[];
+	search_filters: Path_Filter[];
+}
+
+// The relaxed variant that users can provide. Superset of `Gro_Config`.
+export interface Raw_Gro_Config {
+	plugins?: Create_Config_Plugins;
+	map_package_json?: Map_Package_Json | null;
+	task_root_dirs?: string[];
+	search_filters?: Path_Filter | Path_Filter[] | null;
 }
 ```
 
@@ -56,7 +65,7 @@ import type {Create_Gro_Config} from '@ryanatkn/gro';
 import {gro_plugin_sveltekit_app} from '@ryanatkn/gro/gro_plugin_sveltekit_app.js';
 
 const config: Create_Gro_Config = async (cfg) => {
-	// `cfg`, which is equal to `create_empty_config()`,
+	// `cfg`, which has type `Gro_Config` and is equal to `create_empty_config()`,
 	// can be mutated or you can return your own.
 	// A return value is required to avoid potential errors and reduce ambiguity.
 
@@ -80,7 +89,8 @@ const config: Create_Gro_Config = async (cfg) => {
 		);
 		return updated_plugins.concat(create_some_custom_plugin());
 	};
-	return cfg;
+
+	return cfg; // return type is `Raw_Gro_Config`, which is a relaxed superset of `Gro_Config`
 };
 
 export default config;

package/dist/format_directory.d.ts

@@ -1,9 +1,10 @@
 import type { Spawn_Result } from '@ryanatkn/belt/process.js';
 import type { Logger } from '@ryanatkn/belt/log.js';
+import { type Cli } from './cli.js';
 /**
  * Formats a directory on the filesystem.
  * If the source directory is given, it also formats all of the root directory files.
  * This is separated from `./format_file` to avoid importing all of the `prettier` code
  * inside modules that import this one. (which has a nontrivial cost)
  */
-export declare const format_directory: (log: Logger, dir: string, check?: boolean, extensions?: string, root_paths?: string) => Promise<Spawn_Result>;
+export declare const format_directory: (log: Logger, dir: string, check?: boolean, extensions?: string, root_paths?: string, prettier_cli?: string | Cli) => Promise<Spawn_Result>;

package/dist/format_directory.js

@@ -1,7 +1,8 @@
 import { paths } from './paths.js';
 import { GITHUB_DIRNAME, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, GRO_CONFIG_PATH, } from './path_constants.js';
-import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
-import { spawn_cli } from './cli.js';
+import { serialize_args, to_forwarded_args } from './args.js';
+import { spawn_cli, to_cli_name } from './cli.js';
+const PRETTIER_CLI = 'prettier';
 const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
 const DEFAULT_ROOT_PATHS = `${[
     README_FILENAME,
@@ -17,17 +18,16 @@ const DEFAULT_ROOT_PATHS = `${[
  * This is separated from `./format_file` to avoid importing all of the `prettier` code
  * inside modules that import this one. (which has a nontrivial cost)
  */
-export const format_directory = async (log, dir, check = false, extensions = DEFAULT_EXTENSIONS, root_paths = DEFAULT_ROOT_PATHS) => {
-    const forwarded_args = to_forwarded_args('prettier');
+export const format_directory = async (log, dir, check = false, extensions = DEFAULT_EXTENSIONS, root_paths = DEFAULT_ROOT_PATHS, prettier_cli = PRETTIER_CLI) => {
+    const forwarded_args = to_forwarded_args(to_cli_name(prettier_cli));
     forwarded_args[check ? 'check' : 'write'] = true;
     const serialized_args = serialize_args(forwarded_args);
     serialized_args.push(`${dir}**/*.{${extensions}}`);
     if (dir === paths.source) {
         serialized_args.push(`${paths.root}{${root_paths}}`);
     }
-    log.info(print_command_args(serialized_args));
-    const spawned = await spawn_cli('prettier', serialized_args);
+    const spawned = await spawn_cli(prettier_cli, serialized_args, log);
     if (!spawned)
-        throw new Error('failed to find `prettier` CLI locally or globally, do you need to run `npm i`?');
+        throw new Error(`failed to find \`${to_cli_name(prettier_cli)}\` CLI locally or globally, do you need to run \`npm i\`?`);
     return spawned;
 };

package/dist/github.d.ts

@@ -13,16 +13,16 @@ export declare const Github_Pull_Request: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     number: number;
-    url: string;
     id: number;
+    url: string;
     html_url: string;
     user: {
         login: string;
     };
 }, {
     number: number;
-    url: string;
     id: number;
+    url: string;
     html_url: string;
     user: {
         login: string;

package/dist/gro_plugin_sveltekit_app.d.ts

@@ -22,9 +22,13 @@ export interface Options {
      * Pass a function to customize which files get copied.
      */
     well_known_src_files?: boolean | Copy_File_Filter;
+    /**
+     * The Vite CLI to use.
+     */
+    vite_cli?: string;
 }
 export type Host_Target = 'github_pages' | 'static' | 'node';
 export interface Copy_File_Filter {
     (file_path: string): boolean | Promise<boolean>;
 }
-export declare const gro_plugin_sveltekit_app: ({ host_target, well_known_package_json, well_known_src_json, well_known_src_files, }?: Options) => Plugin<Plugin_Context>;
+export declare const gro_plugin_sveltekit_app: ({ host_target, well_known_package_json, well_known_src_json, well_known_src_files, vite_cli, }?: Options) => Plugin<Plugin_Context>;

package/dist/gro_plugin_sveltekit_app.js

@@ -1,26 +1,28 @@
-import { spawn_process } from '@ryanatkn/belt/process.js';
 import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
+import { serialize_args, to_forwarded_args } from './args.js';
 import { serialize_package_json, load_package_json } from './package_json.js';
 import { Task_Error } from './task.js';
-import { spawn_cli } from './cli.js';
+import { find_cli, spawn_cli, spawn_cli_process } from './cli.js';
 import { serialize_src_json, create_src_json } from './src_json.js';
 import { DEFAULT_EXPORTS_EXCLUDER } from './config.js';
 import { sveltekit_config_global } from './sveltekit_config_global.js';
 import { SOURCE_DIRNAME } from './path_constants.js';
-export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_known_package_json, well_known_src_json, well_known_src_files, } = {}) => {
-    let sveltekit_process = null;
+import { VITE_CLI } from './sveltekit_helpers.js';
+export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_known_package_json, well_known_src_json, well_known_src_files, vite_cli = VITE_CLI, } = {}) => {
+    let sveltekit_process = undefined;
     return {
         name: 'gro_plugin_sveltekit_app',
         setup: async ({ dev, watch, log }) => {
+            const found_vite_cli = await find_cli(vite_cli);
+            if (!found_vite_cli)
+                throw new Error(`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`npm i\`?`);
             if (dev) {
                 // `vite dev` in development mode
                 if (watch) {
-                    const serialized_args = ['vite', 'dev', ...serialize_args(to_forwarded_args('vite'))];
-                    log.info(print_command_args(serialized_args));
-                    sveltekit_process = spawn_process('npx', serialized_args);
+                    const serialized_args = ['dev', ...serialize_args(to_forwarded_args(vite_cli))];
+                    sveltekit_process = await spawn_cli_process(found_vite_cli, serialized_args, log);
                 }
                 else {
                     log.debug(`the SvelteKit app plugin is loaded but will not output anything` +
@@ -81,11 +83,10 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                 ].filter(Boolean);
                 const cleanup = () => Promise.all(cleanups.map((c) => c()));
                 try {
-                    const serialized_args = ['build', ...serialize_args(to_forwarded_args('vite'))];
-                    log.info(print_command_args(['vite'].concat(serialized_args)));
-                    const spawned = await spawn_cli('vite', serialized_args); // TODO call with the gro helper instead of npx?
+                    const serialized_args = ['build', ...serialize_args(to_forwarded_args(vite_cli))];
+                    const spawned = await spawn_cli(found_vite_cli, serialized_args, log);
                     if (!spawned?.ok) {
-                        throw new Task_Error('vite build failed with exit code ' + spawned?.code);
+                        throw new Task_Error(`${vite_cli} build failed with exit code ${spawned?.code}`);
                     }
                 }
                 catch (err) {

package/dist/gro_plugin_sveltekit_library.d.ts

@@ -1,2 +1,8 @@
 import type { Plugin, Plugin_Context } from './plugin.js';
-export declare const gro_plugin_sveltekit_library: () => Plugin<Plugin_Context>;
+export interface Options {
+    /**
+     * The SvelteKit packaging CLI to use. Defaults to `svelte-package`.
+     */
+    svelte_package_cli?: string;
+}
+export declare const gro_plugin_sveltekit_library: ({ svelte_package_cli, }?: Options) => Plugin<Plugin_Context>;