@ryanatkn/gro 0.118.0 → 0.119.1

package/README.md

@@ -4,11 +4,12 @@
 
 > task runner and toolkit extending SvelteKit 🌰 generate, run, optimize
 
-[gro.ryanatkn.com](https://gro.ryanatkn.com/)
-
 [`npm i -D @ryanatkn/gro`](https://www.npmjs.com/package/@ryanatkn/gro)
 
-[Windows won't be supported](https://github.com/ryanatkn/gro/issues/319), I chose Bash instead
+[Windows won't be supported](https://github.com/ryanatkn/gro/issues/319), I chose Bash instead.
+
+Feel free to open issues with anything you'd like to discuss or report.
+I also run [a Discord community](https://discord.gg/YU5tyeK72X) that includes channels for Gro.
 
 ## about
 
@@ -106,7 +107,7 @@ gro # prints available tasks - defers to any local gro installation
 Run a task: gro [name]
 View help:  gro [name] --help
 
-17 tasks in gro:
+18 tasks in gro:
 
 build      build the project
 changeset  call changeset with gro patterns
@@ -119,6 +120,7 @@ format     format source files
 gen        run code generation scripts
 lint       run eslint
 publish    bump version, publish to npm, and git push
+reinstall  refreshes package-lock.json with the latest and cleanest deps
 release    publish and deploy
 run        execute a file with the loader, like `node` but works for TypeScript
 sync       run `gro gen`, update `package.json`, and optionally `npm i` to sync up

package/dist/build.task.d.ts

@@ -2,10 +2,13 @@ import { z } from 'zod';
 import type { Task } from './task.js';
 export declare const Args: z.ZodObject<{
     install: z.ZodDefault<z.ZodBoolean>;
+    'no-install': z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     install: boolean;
+    'no-install': boolean;
 }, {
     install?: boolean | undefined;
+    'no-install'?: boolean | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;

package/dist/build.task.js

@@ -3,7 +3,10 @@ import { Plugins } from './plugin.js';
 import { clean_fs } from './clean_fs.js';
 export const Args = z
     .object({
-    install: z.boolean({ description: 'run npm install before building' }).default(false),
+    install: z.boolean({ description: 'dual of no-install' }).default(true),
+    'no-install': z
+        .boolean({ description: 'opt out of npm installing before building' })
+        .default(false),
 })
     .strict();
 export const task = {
@@ -12,6 +15,7 @@ export const task = {
     run: async (ctx) => {
         const { args, invoke_task } = ctx;
         const { install } = args;
+        // By default `gro build` installs, opposite of `gro sync`, so that arg needs special handling.
         await invoke_task('sync', { install });
         // TODO possibly detect if the git workspace is clean, and ask for confirmation if not,
         // because we're not doing things like `gro gen` here because that's a dev/CI concern

package/dist/changeset.task.d.ts

@@ -19,22 +19,22 @@ export declare const Args: z.ZodObject<{
     _: string[];
     dir: string;
     install: boolean;
+    'no-install': boolean;
     origin: string & z.BRAND<"Git_Origin">;
     minor: boolean;
     major: boolean;
     changelog: string;
-    'no-install': boolean;
     access?: "public" | "restricted" | undefined;
 }, {
     _?: string[] | undefined;
     dir?: string | undefined;
     install?: boolean | undefined;
+    'no-install'?: boolean | undefined;
     origin?: string | undefined;
     minor?: boolean | undefined;
     major?: boolean | undefined;
     access?: "public" | "restricted" | undefined;
     changelog?: string | undefined;
-    'no-install'?: boolean | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 /**

package/dist/changeset.task.js

@@ -8,7 +8,7 @@ import { Task_Error } from './task.js';
 import { exists } from './fs.js';
 import { load_package_json } from './package_json.js';
 import { find_cli, spawn_cli } from './cli.js';
-import { Git_Origin, git_push_to_create } from './git.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';
@@ -62,8 +62,9 @@ export const task = {
             throw new Task_Error('changeset command not found: install @changesets/cli locally or globally');
         }
         const package_json = await load_package_json();
-        if (!(await has_sveltekit_library(package_json))) {
-            throw new Task_Error('no SvelteKit library detected');
+        const has_sveltekit_library_result = await has_sveltekit_library(package_json);
+        if (!has_sveltekit_library_result.ok) {
+            throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
         }
         const path = join(dir, 'config.json');
         const inited = await exists(path);
@@ -85,14 +86,17 @@ export const task = {
                 await spawn('npm', ['i', '-D', changelog]);
             }
         }
+        // TODO small problem here where generated files don't get committed
         await invoke_task('sync'); // after the `npm i` above, and in all cases
         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 changeset_adder();
-            await spawn('git', ['commit', '-m', message]);
-            await git_push_to_create(origin);
+            if (!(await git_check_fully_staged_workspace())) {
+                await spawn('git', ['commit', '-m', message]);
+                await git_push_to_create(origin);
+            }
         }
         else {
             await spawn_cli('changeset');

package/dist/check.task.js

@@ -68,7 +68,7 @@ export const task = {
             if (error_message) {
                 log.error(red('git status'));
                 await spawn('git', ['status']);
-                throw new Task_Error('failed check for git_check_clean_workspace:' +
+                throw new Task_Error('Failed check for git_check_clean_workspace:' +
                     error_message +
                     ' - do you need to run `gro sync` or commit some files?');
             }

package/dist/deploy.task.d.ts

@@ -10,17 +10,13 @@ export declare const Args: z.ZodObject<{
     force: z.ZodDefault<z.ZodBoolean>;
     dangerous: z.ZodDefault<z.ZodBoolean>;
     reset: z.ZodDefault<z.ZodBoolean>;
-    install: z.ZodDefault<z.ZodBoolean>;
-    'no-install': z.ZodDefault<z.ZodBoolean>;
     build: z.ZodDefault<z.ZodBoolean>;
     'no-build': z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     build: boolean;
     target: string & z.BRAND<"Git_Branch">;
-    install: boolean;
     origin: string & z.BRAND<"Git_Origin">;
     reset: boolean;
-    'no-install': boolean;
     source: string & z.BRAND<"Git_Branch">;
     deploy_dir: string;
     build_dir: string;
@@ -31,10 +27,8 @@ export declare const Args: z.ZodObject<{
 }, {
     build?: boolean | undefined;
     target?: string | undefined;
-    install?: boolean | undefined;
     origin?: string | undefined;
     reset?: boolean | undefined;
-    'no-install'?: boolean | undefined;
     source?: string | undefined;
     deploy_dir?: string | undefined;
     build_dir?: string | undefined;

package/dist/deploy.task.js

@@ -10,7 +10,6 @@ import { GRO_DIRNAME, GIT_DIRNAME, SVELTEKIT_BUILD_DIRNAME } from './path_consta
 import { empty_dir, exists } from './fs.js';
 import { git_check_clean_workspace, git_checkout, git_local_branch_exists, git_remote_branch_exists, Git_Origin, Git_Branch, git_delete_local_branch, git_push_to_create, git_reset_branch_to_first_commit, git_pull, git_fetch, git_check_setting_pull_rebase, git_clone_locally, git_current_branch_name, } from './git.js';
 // docs at ./docs/deploy.md
-// TODO use `to_forwarded_args` and the `gro deploy -- gro build --no-install` pattern to remove the `install`/`no-install` args (also needs testing, maybe a custom override for `gro ` prefixes)
 // terminal command for testing:
 // npm run build && rm -rf .gro && clear && gro deploy --source no-git-workspace --no-build --dry
 // TODO customize
@@ -46,10 +45,6 @@ export const Args = z
         description: 'if true, resets the target branch back to the first commit before deploying',
     })
         .default(false),
-    install: z.boolean({ description: 'dual of no-install' }).default(true),
-    'no-install': z
-        .boolean({ description: 'opt out of npm installing before building' })
-        .default(false),
     build: z.boolean({ description: 'dual of no-build' }).default(true),
     'no-build': z.boolean({ description: 'opt out of building' }).default(false),
 })
@@ -58,7 +53,7 @@ export const task = {
     summary: 'deploy to a branch',
     Args,
     run: async ({ args, log, invoke_task }) => {
-        const { source, target, origin, build_dir, deploy_dir, dry, force, dangerous, reset, install, build, } = args;
+        const { source, target, origin, build_dir, deploy_dir, dry, force, dangerous, reset, build } = args;
         // Checks
         if (!force && target !== TARGET_BRANCH) {
             throw new Task_Error(`Warning! You are deploying to a custom target branch '${target}',` +
@@ -163,7 +158,7 @@ export const task = {
         // Build
         try {
             if (build) {
-                await invoke_task('build', { install });
+                await invoke_task('build');
             }
             if (!(await exists(build_dir))) {
                 log.error(red('directory to deploy does not exist after building:'), build_dir);

package/dist/dev.task.d.ts

@@ -7,13 +7,13 @@ export declare const Args: z.ZodObject<{
     sync: z.ZodDefault<z.ZodBoolean>;
     'no-sync': z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    watch: boolean;
     sync: boolean;
+    watch: boolean;
     'no-watch': boolean;
     'no-sync': boolean;
 }, {
-    watch?: boolean | undefined;
     sync?: boolean | undefined;
+    watch?: boolean | undefined;
     'no-watch'?: boolean | undefined;
     'no-sync'?: boolean | undefined;
 }>;

package/dist/docs/gen.md

@@ -52,6 +52,17 @@ There's no support for sourcemaps yet, and I have no plans for them.
 (I would accept contributions, but I think it's a hard problem to do well,
 and I don't know what the payoffs would be)
 
+> ⚠️ Generated files should never be edited directly,
+> because the next time `gro gen` or `gro sync` runs,
+> any uncommitted changes will be lost!
+> I considered making `gen` only write to files that have no uncommitted changes,
+> but that would impede many workflows,
+> and I don't want to nudge users towards a habit of always adding an override flag.
+> I can see one possible improvement that lets the user
+> opt into making gen write only to unchanged files for those workflows that don't mind it,
+> so if you would like to see that or something similar,
+> please open an issue or [share your thoughts on Discord](https://discord.gg/YU5tyeK72X).
+
 Inspirations include Lisp macros, the
 [Svelte](https://github.com/sveltejs/svelte) compiler,
 and [Zig](https://github.com/ziglang/zig)'s comptime.

package/dist/docs/publish.md

@@ -52,14 +52,7 @@ a changeset to an already-inited repo, use `gro changeset`:
 
 ```bash
 gro changeset # inits or adds a changeset
-gro changeset --help # prints:
-gro changeset: call changeset with gro patterns
-
-[...args]   string[]                 []                           the commands to pass to changeset
-path        string                   './.changeset/config.json'   changeset config file path
-access      'restricted' | 'public'  undefined                    changeset 'access' config value, the default depends on package.json#private
-changelog   string                   '@changesets/changelog-git'  changeset "changelog" config value
-no-install  boolean                  false                        opt out of npm installing the changelog package
+gro changeset --help # view the args docs
 
 # `gro changeset` is equivalent to:
 changeset init # if needed -- prefix with `npx ` if installed only locally

package/dist/docs/task.md

@@ -310,6 +310,11 @@ then `--a` and `--b` will be forwarded to `taskname2`.
 Forwarded args to Gro tasks override direct args, including args to `invoke_task`,
 so `gro taskname --a 1 -- gro taskname --a 2` will invoke `taskname` with `{a: 2}`.
 
+The `invoke_task` helper in the task context forwards the CLI args for the specified task.
+CLI args take precedence over args passed directly to `invoke_task`.
+This may not always be the desired behavior, but it gives the user more control,
+because you can't change args in code you don't control.
+
 ### throwing errors
 
 If a task encounters an error, normally it should throw rather than exiting the process.
@@ -355,6 +360,8 @@ What makes Gro different?
   and improved DX with new capabilities.
 - Tasks support CLI args that are validated and typesafe
   via colocated Zod schemas with minimal boilerplate.
+- Tasks are forwarded CLI args when called via `invoke_task` in other tasks,
+  so running `gro foo -- gro bar --a b` passes `{a: 'b'}` automatically to the `bar` task.
 - Module resolution differs and leverages discoverability:
   - When a task name is given to Gro,
     it first searches `src/lib/` in the current working directory and

package/dist/docs/tasks.md

@@ -17,6 +17,7 @@ What is a `Task`? See [`task.md`](./task.md).
 - [gen](../gen.task.ts) - run code generation scripts
 - [lint](../lint.task.ts) - run eslint
 - [publish](../publish.task.ts) - bump version, publish to npm, and git push
+- [reinstall](../reinstall.task.ts) - refreshes package-lock.json with the latest and cleanest deps
 - [release](../release.task.ts) - publish and deploy
 - [run](../run.task.ts) - execute a file with the loader, like `node` but works for TypeScript
 - [sync](../sync.task.ts) - run `gro gen`, update `package.json`, and optionally `npm i` to sync up

package/dist/format_directory.d.ts

@@ -1,2 +1,8 @@
-import { type Spawn_Result } from '@ryanatkn/belt/process.js';
-export declare const format_directory: (log: Logger, directory: string, check?: boolean, extensions?: string, root_paths?: string) => Promise<Spawn_Result>;
+import type { Spawn_Result } from '@ryanatkn/belt/process.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>;

package/dist/format_directory.js

@@ -1,7 +1,7 @@
-import { spawn } from '@ryanatkn/belt/process.js';
 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';
 const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
 const DEFAULT_ROOT_PATHS = `${[
     README_FILENAME,
@@ -11,18 +11,23 @@ const DEFAULT_ROOT_PATHS = `${[
     TSCONFIG_FILENAME,
     GITHUB_DIRNAME,
 ].join(',')}/**/*`;
-// This 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 const format_directory = (log, directory, check = false, extensions = DEFAULT_EXTENSIONS, root_paths = DEFAULT_ROOT_PATHS) => {
+/**
+ * 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 const format_directory = async (log, dir, check = false, extensions = DEFAULT_EXTENSIONS, root_paths = DEFAULT_ROOT_PATHS) => {
     const forwarded_args = to_forwarded_args('prettier');
     forwarded_args[check ? 'check' : 'write'] = true;
-    const serialized_args = ['prettier', ...serialize_args(forwarded_args)];
-    serialized_args.push(`${directory}**/*.{${extensions}}`);
-    if (directory === paths.source) {
+    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));
-    return spawn('npx', serialized_args);
+    const spawned = await spawn_cli('prettier', serialized_args);
+    if (!spawned)
+        throw new Error('failed to find `prettier` CLI locally or globally, do you need to run `npm i`?');
+    return spawned;
 };

package/dist/gen.d.ts

@@ -60,3 +60,17 @@ export type Gen_Module_Result_Failure = {
 };
 export declare const to_gen_result: (origin_id: Flavored<string, "Source_Id">, raw_result: Raw_Gen_Result) => Gen_Result;
 export declare const to_output_file_name: (filename: string) => string;
+export type Analyzed_Gen_Result = {
+    file: Gen_File;
+    existing_content: string;
+    is_new: false;
+    has_changed: boolean;
+} | {
+    file: Gen_File;
+    existing_content: null;
+    is_new: true;
+    has_changed: true;
+};
+export declare const analyze_gen_results: (gen_results: Gen_Results) => Promise<Analyzed_Gen_Result[]>;
+export declare const analyze_gen_result: (file: Gen_File) => Promise<Analyzed_Gen_Result>;
+export declare const write_gen_results: (gen_results: Gen_Results, analyzed_gen_results: Analyzed_Gen_Result[], log: Logger) => Promise<void>;

package/dist/gen.js

@@ -1,6 +1,9 @@
 import { join, basename, dirname, isAbsolute } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { gen_module_meta, to_gen_module_type } from './gen_module.js';
+import { print_path } from './paths.js';
+import { exists } from './fs.js';
 export const Gen_Config = z.object({
     imports: z.record(z.string(), z.string()).default({}),
 });
@@ -79,3 +82,45 @@ const validate_gen_files = (files) => {
         ids.add(file.id);
     }
 };
+export const analyze_gen_results = (gen_results) => Promise.all(gen_results.successes
+    .map((result) => result.files.map((file) => analyze_gen_result(file)))
+    .flat());
+export const analyze_gen_result = async (file) => {
+    if (!(await exists(file.id))) {
+        return {
+            file,
+            existing_content: null,
+            is_new: true,
+            has_changed: true,
+        };
+    }
+    const existing_content = await readFile(file.id, 'utf8');
+    return {
+        file,
+        existing_content,
+        is_new: false,
+        has_changed: file.content !== existing_content,
+    };
+};
+export const write_gen_results = async (gen_results, analyzed_gen_results, log) => {
+    await Promise.all(gen_results.successes
+        .map((result) => result.files.map(async (file) => {
+        const analyzed = analyzed_gen_results.find((r) => r.file.id === file.id);
+        if (!analyzed)
+            throw Error('Expected to find analyzed result: ' + file.id);
+        const log_args = [print_path(file.id), 'generated from', print_path(file.origin_id)];
+        if (analyzed.is_new) {
+            log.info('writing new', ...log_args);
+            await mkdir(dirname(file.id), { recursive: true });
+            await writeFile(file.id, file.content);
+        }
+        else if (analyzed.has_changed) {
+            log.info('writing changed', ...log_args);
+            await writeFile(file.id, file.content);
+        }
+        else {
+            log.info('skipping unchanged', ...log_args);
+        }
+    }))
+        .flat());
+};

package/dist/gen.task.js

@@ -2,16 +2,15 @@ import { red, green, gray } from 'kleur/colors';
 import { print_ms, print_error } from '@ryanatkn/belt/print.js';
 import { plural } from '@ryanatkn/belt/string.js';
 import { z } from 'zod';
-import { dirname } from 'node:path';
-import { mkdir, writeFile } from 'node:fs/promises';
 import { Task_Error } from './task.js';
 import { run_gen } from './run_gen.js';
-import { load_gen_module, check_gen_modules, find_gen_modules } from './gen_module.js';
+import { load_gen_module, find_gen_modules } from './gen_module.js';
 import { Raw_Input_Path, to_input_paths } from './input_path.js';
 import { load_modules } from './modules.js';
 import { format_file } from './format_file.js';
 import { paths, print_path } from './paths.js';
 import { log_error_reasons } from './task_logging.js';
+import { write_gen_results, analyze_gen_results } from './gen.js';
 export const Args = z
     .object({
     _: z.array(Raw_Input_Path, { description: 'paths to generate' }).default([]),
@@ -51,20 +50,20 @@ export const task = {
         const gen_results = await run_gen(load_modules_result.modules, config, log, timings, format_file);
         timing_to_generate_code();
         const fail_count = gen_results.failures.length;
+        const analyzed_gen_results = await analyze_gen_results(gen_results);
         if (check) {
             // check if any files changed, and if so, throw errors,
             // but if there are gen failures, skip the check and defer to their errors
             if (!fail_count) {
                 log.info('checking generated files for changes');
                 const timing_to_check_results = timings.start('check results for changes');
-                const check_gen_modules_results = await check_gen_modules(gen_results);
                 timing_to_check_results();
                 let has_unexpected_changes = false;
-                for (const result of check_gen_modules_results) {
-                    if (!result.has_changed)
+                for (const analyzed of analyzed_gen_results) {
+                    if (!analyzed.has_changed)
                         continue;
                     has_unexpected_changes = true;
-                    log.error(red(`Generated file ${print_path(result.file.id)} via ${print_path(result.file.origin_id)} ${result.is_new ? 'is new' : 'has changed'}.`));
+                    log.error(red(`Generated file ${print_path(analyzed.file.id)} via ${print_path(analyzed.file.origin_id)} ${analyzed.is_new ? 'is new' : 'has changed'}.`));
                 }
                 if (has_unexpected_changes) {
                     throw new Task_Error('Failed gen check. Some generated files have unexpectedly changed.' +
@@ -77,20 +76,21 @@ export const task = {
             // write generated files to disk
             log.info('writing generated files to disk');
             const timing_to_output_results = timings.start('output results');
-            await Promise.all(gen_results.successes
-                .map((result) => result.files.map(async (file) => {
-                log.info('writing', print_path(file.id), 'generated from', print_path(file.origin_id));
-                await mkdir(dirname(file.id), { recursive: true });
-                await writeFile(file.id, file.content);
-            }))
-                .flat());
+            await write_gen_results(gen_results, analyzed_gen_results, log);
             timing_to_output_results();
         }
-        let logResult = '';
+        // TODO these final printed results could be improved showing a breakdown per file id
+        const new_count = analyzed_gen_results.filter((r) => r.is_new).length;
+        const changed_count = analyzed_gen_results.filter((r) => r.has_changed).length;
+        const skipped_count = analyzed_gen_results.filter((r) => !r.is_new && !r.has_changed).length;
+        let log_result = green('gen results:');
+        log_result += `\n\t${new_count} ` + gray('new');
+        log_result += `\n\t${changed_count} ` + gray('changed');
+        log_result += `\n\t${skipped_count} ` + gray('skipped');
         for (const result of gen_results.results) {
-            logResult += `\n\t${result.ok ? green('✓') : red('🞩')}  ${result.ok ? result.files.length : 0} ${gray('in')} ${print_ms(result.elapsed)} ${gray('←')} ${print_path(result.id)}`;
+            log_result += `\n\t${result.ok ? green('✓') : red('🞩')}  ${result.ok ? result.files.length : 0} ${gray('in')} ${print_ms(result.elapsed)} ${gray('←')} ${print_path(result.id)}`;
         }
-        log.info(logResult);
+        log.info(log_result);
         log.info(green(`generated ${gen_results.output_count} file${plural(gen_results.output_count)} from ${gen_results.successes.length} input file${plural(gen_results.successes.length)}`));
         if (fail_count) {
             for (const result of gen_results.failures) {

package/dist/gen_module.d.ts

@@ -1,5 +1,5 @@
 import { type Module_Meta, type Load_Module_Result, type Find_Modules_Result } from './modules.js';
-import type { Gen, Gen_Results, Gen_File } from './gen.js';
+import type { Gen } from './gen.js';
 import { Input_Path } from './input_path.js';
 export declare const GEN_FILE_PATTERN_TEXT = "gen";
 export declare const GEN_FILE_PATTERN: string;
@@ -31,17 +31,4 @@ export interface Basic_Gen_Module_Meta extends Module_Meta<Gen_Module> {
     mod: Basic_Gen_Module;
 }
 export declare const load_gen_module: (id: string) => Promise<Load_Module_Result<Gen_Module_Meta>>;
-export type Check_Gen_Module_Result = {
-    file: Gen_File;
-    existing_content: string;
-    is_new: false;
-    has_changed: boolean;
-} | {
-    file: Gen_File;
-    existing_content: null;
-    is_new: true;
-    has_changed: true;
-};
-export declare const check_gen_modules: (gen_results: Gen_Results) => Promise<Check_Gen_Module_Result[]>;
-export declare const check_gen_module: (file: Gen_File) => Promise<Check_Gen_Module_Result>;
 export declare const find_gen_modules: (input_paths?: Input_Path[], extensions?: string[], root_dirs?: string[]) => Promise<Find_Modules_Result>;

package/dist/gen_module.js

@@ -1,9 +1,7 @@
-import { readFile } from 'node:fs/promises';
 import { load_module, find_modules, } from './modules.js';
 import { Input_Path, get_possible_source_ids } from './input_path.js';
 import { paths } from './paths.js';
 import { search_fs } from './search_fs.js';
-import { exists } from './fs.js';
 export const GEN_FILE_PATTERN_TEXT = 'gen';
 export const GEN_FILE_PATTERN = '.' + GEN_FILE_PATTERN_TEXT + '.';
 export const is_gen_path = (path) => path.includes(GEN_FILE_PATTERN);
@@ -28,26 +26,6 @@ export const load_gen_module = async (id) => {
     }
     return result;
 };
-export const check_gen_modules = (gen_results) => Promise.all(gen_results.successes
-    .map((result) => result.files.map((file) => check_gen_module(file)))
-    .flat());
-export const check_gen_module = async (file) => {
-    if (!(await exists(file.id))) {
-        return {
-            file,
-            existing_content: null,
-            is_new: true,
-            has_changed: true,
-        };
-    }
-    const existing_content = await readFile(file.id, 'utf8');
-    return {
-        file,
-        existing_content,
-        is_new: false,
-        has_changed: file.content !== existing_content,
-    };
-};
 export const find_gen_modules = (input_paths = [paths.source], 
 // TODO improve this API to allow config, maybe just a simple `gen` filter function, so the user could return a Rollup pluginutils filter,
 // gets a little tricky with the `get_possible_source_ids` API usage, which would probably need to change

package/dist/git.d.ts

@@ -22,6 +22,11 @@ export declare const git_local_branch_exists: (branch: Git_Branch, options?: Spa
  * @returns an error message if the git workspace has any unstaged or uncommitted changes, or `null` if it's clean
  */
 export declare const git_check_clean_workspace: (options?: SpawnOptions) => Promise<string | null>;
+/**
+ * TODO make this return an enum and separate the text into a different function
+ * @returns an error message if the git workspace has any unstaged stages, or `null` if it's clean
+ */
+export declare const git_check_fully_staged_workspace: (options?: SpawnOptions) => Promise<string | null>;
 /**
  * Calls `git fetch` and throws if anything goes wrong.
  */

package/dist/git.js

@@ -63,6 +63,21 @@ export const git_check_clean_workspace = async (options) => {
     }
     return null;
 };
+/**
+ * TODO make this return an enum and separate the text into a different function
+ * @returns an error message if the git workspace has any unstaged stages, or `null` if it's clean
+ */
+export const git_check_fully_staged_workspace = async (options) => {
+    const unstaged_result = await spawn('git', ['diff', '--exit-code', '--quiet'], options);
+    if (!unstaged_result.ok) {
+        return 'git has unstaged changes';
+    }
+    const status_result = await spawn_out('git', ['status', '--porcelain'], options);
+    if (status_result.stdout?.includes('??')) {
+        return 'git has untracked files';
+    }
+    return null;
+};
 /**
  * Calls `git fetch` and throws if anything goes wrong.
  */

package/dist/git.test.js

@@ -1,6 +1,6 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
-import { git_check_clean_workspace, git_current_branch_first_commit_hash, git_current_branch_name, git_current_commit_hash, } from './git.js';
+import { git_check_clean_workspace, git_check_fully_staged_workspace, git_current_branch_first_commit_hash, git_current_branch_name, git_current_commit_hash, } from './git.js';
 test('git_current_branch_name', async () => {
     const branch_name = await git_current_branch_name();
     assert.ok(branch_name);
@@ -8,6 +8,9 @@ test('git_current_branch_name', async () => {
 test('git_check_clean_workspace', async () => {
     await git_check_clean_workspace();
 });
+test('git_check_fully_staged_workspace', async () => {
+    await git_check_fully_staged_workspace();
+});
 test('git_current_commit_hash', async () => {
     await git_current_commit_hash();
 });

package/dist/gro.config.default.js

@@ -12,16 +12,12 @@ import { has_sveltekit_app, has_sveltekit_library } from './sveltekit_helpers.js
  * - if `src/lib/server/server.ts`, assumes a Node server
  */
 const config = async (cfg) => {
-    const [enable_sveltekit_library, enable_server, enable_sveltekit_app] = await Promise.all([
-        has_sveltekit_library(),
-        has_server(),
-        has_sveltekit_app(),
-    ]);
+    const [has_sveltekit_library_result, has_server_result, has_sveltekit_app_result] = await Promise.all([has_sveltekit_library(), has_server(), has_sveltekit_app()]);
     cfg.plugins = async () => [
-        enable_sveltekit_library ? gro_plugin_sveltekit_library() : null,
-        enable_server ? gro_plugin_server() : null,
-        enable_sveltekit_app
-            ? gro_plugin_sveltekit_app({ host_target: enable_server ? 'node' : 'github_pages' })
+        has_sveltekit_library_result.ok ? gro_plugin_sveltekit_library() : null,
+        has_server_result.ok ? gro_plugin_server() : null,
+        has_sveltekit_app_result.ok
+            ? gro_plugin_sveltekit_app({ host_target: has_server_result.ok ? 'node' : 'github_pages' })
             : null,
         // TODO replace with an esbuild plugin, see the module for more
         // import {gro_plugin_gen} from './gro_plugin_gen.js';