@ryanatkn/gro 0.116.2 → 0.118.0

package/README.md

@@ -35,8 +35,7 @@ It includes:
     [`@sveltejs/package`](https://kit.svelte.dev/docs/packaging) for the library
   - exposes all of its internals in `$lib`
   - uses [Changesets](https://github.com/changesets/changesets) for versioning and changelogs
-  - provides a [Node loader](/src/lib/loader.ts) and
-    [esbuild plugins for the server](/src/lib/gro_plugin_server.ts)
+  - provides a [Node loader](/src/lib/loader.ts) with a [register hook](/src/lib/register.ts)
     - supports importing TypeScript, JSON, and SSR'd Svelte files in tests and tasks
     - supports [SvelteKit module imports](https://kit.svelte.dev/docs/modules) for
       `$lib`, `$env`, and `$app` in tasks, tests, Node servers,
@@ -44,8 +43,10 @@ It includes:
       so you can use SvelteKit patterns everywhere
       (these are best-effort shims, not perfect)
     - supports running TypeScript files directly without a task via `gro run a.ts`
-  - [configurable plugins](/src/lib/docs/plugin.md)
-    to support SvelteKit, auto-restarting Node servers, and other external build processes
+      or `node --import @ryanatkn/gro/register.js a.ts`
+  - [configurable plugins](/src/lib/docs/plugin.md) to support SvelteKit,
+    [auto-restarting Node servers](/src/lib/gro_plugin_server.ts),
+    and other external build processes
     - see the [Gro config docs](/src/lib/docs/config.md) and
       [the default config](https://github.com/ryanatkn/gro/blob/main/src/lib/gro.config.default.ts)
     - see [`fuz_template`](https://github.com/fuz-dev/fuz_template)
@@ -126,17 +127,34 @@ typecheck  run tsc on the project without emitting any files
 upgrade    upgrade deps
 ```
 
-Gro matches your CLI input against its filesystem conventions.
+To run tasks, Gro matches your CLI input against its filesystem conventions.
 It tries to do the right thing, where right is helpful but not surprising,
 with some magic but not too much:
 
 ```bash
-gro # print all available tasks, those matching `src/lib/**/*.task.ts` and Gro's builtins
-gro some/dir # list all tasks inside `src/lib/some/dir`
-gro some/file # run `src/lib/some/file.task.ts`
+gro # displays all available tasks matching `src/lib/**/*.task.ts` and Gro's builtins
+gro a # tries to run `src/lib/a.task.ts`, then `./a.task.ts`, then Gro's builtin if one exists
+gro a --help # displays docs for the "a" task and its args, works for every task
+gro some/dir # lists all tasks inside `src/lib/some/dir`
+gro some/file # runs `src/lib/some/file.task.ts`
 gro some/file.task.ts # same as above
-gro a # run `src/lib/a.task.ts` if it exists, falling back to Gro's builtin
-gro a --help # print info about the "a" task; works for every task
+```
+
+Gro can also run non-task TypeScript files directly
+with [the `gro run` task](/src/lib/run.task.ts) or [register hook](/src/lib/register.ts):
+
+```bash
+gro run foo.ts
+node --import @ryanatkn/gro/register.js foo.ts
+```
+
+Or programmatically:
+
+```js
+// myfile.js
+import {register} from 'node:module';
+register('@ryanatkn/gro/loader.js', import.meta.url);
+await import('./foo.ts');
 ```
 
 Gro has a number of builtin tasks that you can run with the CLI.
@@ -200,19 +218,17 @@ To publish: (also see [`src/lib/docs/publish.md`](/src/lib/docs/publish.md))
 gro publish # flush changeset to changelog, bump version, publish to npm, and git push
 ```
 
-Etc:
+More:
 
 ```bash
 gro clean # delete all build artifacts from the filesystem
 gro clean --sveltekit --nodemodules --git # also deletes dirs and prunes git branches
 gro upgrade excluded-dep-1 excluded-dep-2 # npm updates to the latest everything
-```
-
-```bash
 gro --version # print the Gro version
 ```
 
-For more see [`src/lib/docs/task.md`](/src/lib/docs/task.md) and [`src/lib/docs`](/src/lib/docs).
+For more see [the tasks index](/src/lib/docs/tasks.md),
+[the task feature docs](/src/lib/docs/task.md), and [the docs index](/src/lib/docs/README.md).
 
 ## develop
 

package/dist/changeset.task.js

@@ -9,7 +9,7 @@ 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 { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
+import { has_sveltekit_library } from './sveltekit_helpers.js';
 const RESTRICTED_ACCESS = 'restricted';
 const PUBLIC_ACCESS = 'public';
 const CHANGESET_DIR = '.changeset';

package/dist/clean_fs.js

@@ -1,5 +1,6 @@
 import { rm, readdir } from 'node:fs/promises';
-import { NODE_MODULES_DIRNAME, paths, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, GRO_DIST_PREFIX, SVELTEKIT_DIST_DIRNAME, } from './paths.js';
+import { paths } from './paths.js';
+import { NODE_MODULES_DIRNAME, GRO_DIST_PREFIX, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, SVELTEKIT_DIST_DIRNAME, } from './path_constants.js';
 export const clean_fs = async ({ build = false, build_dev = false, build_dist = false, sveltekit = false, nodemodules = false, }, rm_options = { force: true, recursive: true }) => {
     const promises = [];
     if (build) {

package/dist/cli.js

@@ -1,7 +1,7 @@
 import { spawn, spawn_out } from '@ryanatkn/belt/process.js';
 import { join } from 'node:path';
 import { exists } from './fs.js';
-import { NODE_MODULES_DIRNAME } from './paths.js';
+import { NODE_MODULES_DIRNAME } from './path_constants.js';
 /**
  * Looks for the CLI `name`, first local to the cwd and then globally.
  */

package/dist/config.d.ts

@@ -8,6 +8,11 @@ export interface Gro_Config {
      * Returning `null` is a no-op for the caller.
      */
     map_package_json: Map_Package_Json | null;
+    /**
+     * 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_paths: string[];
 }
 export interface Create_Gro_Config {
     (base_config: Gro_Config): Gro_Config | Promise<Gro_Config>;

package/dist/config.js

@@ -1,11 +1,13 @@
-import { join } from 'node:path';
-import { CONFIG_PATH, paths } from './paths.js';
+import { join, resolve } from 'node:path';
+import { GRO_DIST_DIR, IS_THIS_GRO, paths } from './paths.js';
+import { GRO_CONFIG_PATH } from './path_constants.js';
 import create_default_config from './gro.config.default.js';
 import { exists } from './fs.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_paths: [paths.lib, paths.root, IS_THIS_GRO ? null : GRO_DIST_DIR].filter(Boolean),
 });
 const default_map_package_json = async (package_json) => {
     if (package_json.exports) {
@@ -16,7 +18,7 @@ const default_map_package_json = async (package_json) => {
 export const DEFAULT_EXPORTS_EXCLUDER = /(\.md|\.(test|ignore)\.|\/(test|fixtures|ignore)\/)/u;
 export const load_config = async (dir = paths.root) => {
     const default_config = await create_default_config(create_empty_config());
-    const config_path = join(dir, CONFIG_PATH);
+    const config_path = join(dir, GRO_CONFIG_PATH);
     let config;
     if (await exists(config_path)) {
         const config_module = await import(config_path);
@@ -25,12 +27,18 @@ export const load_config = async (dir = paths.root) => {
             typeof config_module.default === 'function'
                 ? await config_module.default(default_config)
                 : config_module.default;
+        normalize_config(config);
     }
     else {
         config = default_config;
     }
     return config;
 };
+// Mutates `config` with cleaned up values.
+const normalize_config = (config) => {
+    // TODO any validation?
+    config.task_root_paths = config.task_root_paths.map((p) => resolve(p));
+};
 export const validate_config_module = (config_module, config_path) => {
     const config = config_module.default;
     if (!config) {

package/dist/deploy.task.js

@@ -5,7 +5,8 @@ import { z } from 'zod';
 import { cp, mkdir, readdir, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { Task_Error } from './task.js';
-import { GIT_DIRNAME, GRO_DIRNAME, print_path, SVELTEKIT_BUILD_DIRNAME } from './paths.js';
+import { print_path } from './paths.js';
+import { GRO_DIRNAME, GIT_DIRNAME, SVELTEKIT_BUILD_DIRNAME } from './path_constants.js';
 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
@@ -13,7 +14,7 @@ import { git_check_clean_workspace, git_checkout, git_local_branch_exists, git_r
 // terminal command for testing:
 // npm run build && rm -rf .gro && clear && gro deploy --source no-git-workspace --no-build --dry
 // TODO customize
-const cwd = process.cwd();
+const dir = process.cwd();
 const INITIAL_FILE_PATH = '.gitkeep';
 const INITIAL_FILE_CONTENTS = '';
 const DEPLOY_DIR = GRO_DIRNAME + '/deploy';
@@ -121,7 +122,7 @@ export const task = {
             if (!(await exists(resolved_deploy_dir))) {
                 const local_deploy_branch_exists = await git_local_branch_exists(target);
                 await git_fetch(origin, ('+' + target + ':' + target)); // fetch+merge and allow non-fastforward updates with the +
-                await git_clone_locally(origin, target, cwd, resolved_deploy_dir);
+                await git_clone_locally(origin, target, dir, resolved_deploy_dir);
                 // Clean up if we created the target branch in the cwd
                 if (!local_deploy_branch_exists) {
                     await git_delete_local_branch(target);
@@ -145,7 +146,7 @@ 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, cwd, resolved_deploy_dir);
+            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 . && ` +

package/dist/docs/config.md

@@ -44,6 +44,7 @@ export interface Create_Gro_Config {
 export interface Gro_Config {
 	plugins: Create_Config_Plugins;
 	map_package_json: Map_Package_Json | null;
+	task_root_paths: string[];
 }
 ```
 
@@ -80,6 +81,20 @@ const config: Create_Gro_Config = async (cfg) => {
 export default config;
 ```
 
+You can also export a config object and use `create_empty_config` to get the defaults:
+
+```ts
+import {create_empty_config} from '@ryanatkn/gro/config.js';
+
+const config = create_empty_config();
+
+// config.plugins = ...;
+// config.map_package_json = ...;
+// config.task_root_paths = ...;
+
+export default config;
+```
+
 See also [Gro's own internal config](/gro.config.ts).
 
 ## `plugins`
@@ -160,3 +175,13 @@ export interface Map_Package_Json {
 	(package_json: Package_Json): Package_Json | null | Promise<Package_Json | null>;
 }
 ```
+
+## `task_root_paths`
+
+The Gro config option `task_root_paths` allows customizing Gro's task resolution.
+When calling `gro [input_path]`, absolute and explicitly relative paths starting with `.`
+are resolved according to normal filesystem rules,
+but non-explicit input paths, like `foo`, are resolved by searching
+through `task_root_paths` in order until a matching file or directory is found on the filesystem.
+
+The default task paths are `./src/lib`, then `.`, and then Gro's dist directory.

package/dist/docs/gen.md

@@ -91,6 +91,22 @@ Outputs `src/script.ts`:
 console.log('generated a string');
 ```
 
+### gen context
+
+The `Gen` function receives one argument, the `Gen_Context` object:
+
+```ts
+export interface Gen_Context {
+	config: Gro_Config;
+	/**
+	 * Same as `import.meta.url` but in path form.
+	 */
+	origin_id: string;
+	log: Logger;
+}
+// export const gen: Gen = ({config, origin_id, log}) => {
+```
+
 ### generate other filetypes
 
 Files with any extension can be generated without configuration.

package/dist/docs/task.md

@@ -21,30 +21,29 @@ and defers composition to the user in regular TypeScript modules.
 > use the `gro run` task, which works like the normal `node` CLI
 > but uses the Gro loader to support `.ts`.
 
-- Gro automatically discovers [all `*.task.ts` files](../docs/tasks.md)
-  in your source directory, so creating a new task
-  is as simple as [creating a new file](#define-a-task), no config needed,
-  but part of the convention is that Gro expects all source code to be in `src/`
+- tasks are defined by naming files with the `.task.ts` and `.task.js` suffixes
+- tasks can be run from the CLI via a name (`gro foo`),
+  which uses Gro's task resolution (see more below),
+  or via paths that are absolute (`gro /path/to/foo`) or explicitly relative (`gro ./foo`)
+- Gro automatically discovers all `*.task.ts|js` files
+  in its configurable directory, so creating a new task
+  is as simple as [creating a new file](#define-a-task), no config needed
+  (defaults to `src/lib`, see the config option [`task_root_paths`](./config.md#task_root_paths))
+- to view [the available tasks](https://github.com/ryanatkn/gro/blob/main/src/lib/docs/tasks.md)
+  run `gro` with no arguments
 - task definitions are just objects with an async `run` function and some optional properties,
   so composing tasks is explicit in your code, just like any other module
-  (but there's also the helper `invoke_task`: see more below)
-- on the command line, tasks replace the concept of commands,
-  so running them is as simple as `gro <task>`,
-  and in code the task object's `run` function has access to CLI args;
-  to view [the available tasks](https://github.com/ryanatkn/gro/blob/main/src/lib/docs/tasks.md)
-  run `gro` with no arguments
+  (but there's also the helper `invoke_task`, see more below)
+- the task object's `run` function has access to CLI args
 - tasks optionally use [zod](https://github.com/colinhacks/zod) schemas
   for `args` types, runtime parsing with helpful validation errors,
-  and automatic help output, with DRY co-located definitions
-- it's easy to hook into or override any of Gro's builtin tasks,
-  like [`gro test`](/src/lib/test.task.ts) and [`gro gen`](/src/lib/gen.task.ts)
-  (tasks are copy-paste friendly! just update the imports)
-- the task execution environment is filesystem agnostic by default; `run` receives a
-  [`Task_Context` argument](#user-content-types-task-and-taskcontext) with an `fs` property
-- the `Task_Context` provides a rich baseline context object
-  for both development/build tasks and one-off script authoring/execution;
-  it attempts to be portable and extensibile, but there's a _lot_ of room for improvement
-- it's fast because it imports only the modules that your chosen tasks need
+  and generated help docs (`gro foo --help`), with DRY co-located definitions
+- it's easy to call into or override any of Gro's builtin tasks,
+  like [`gro test`](/src/lib/test.task.ts) and [`gro gen`](/src/lib/gen.task.ts) -
+  your own versions with the same name take precedence, and you can invoke the base
+  tasks using the `gro/` prefix, e.g. `gro gro/test`
+  (tasks are also copy-paste friendly! just update the imports)
+- it's fast because it imports only the modules imported by your invoked tasks, not every task's
 
 The task runner's purpose is to provide an ergonomic interface
 between the CLI, build tools, and app code.
@@ -55,18 +54,24 @@ As a developer, it's nice to be able to reuse TypeScript modules in every contex
 ### show all available tasks
 
 ```bash
-# This looks through `src/` in both the current working directory
-# and Gro's source for all files matching `*.task.ts` and logs them out.
+# This looks through `src/lib` in both the current working directory and Gro's source
+# for all files matching `*.task.ts|js` and logs them out with their args docs.
 $ gro
 ```
 
-> notice that Gro is hardcoded to expect all tasks to be in `src/` --
-> it would be nice to loosen this up, but the API isn't obvious to me right now
+The [config](./config.md) option [task_root_paths](./config.md#task_root_paths)
+tells Gro where to search for tasks.
+
+> Currently, only the first directory specified in `task_root_paths` that's found on the filesystem
+> will be used to automatically discover tasks, like when running `gro` without args.
+> Please open an issue if you would like to see Gro be able to discover
+> tasks in more than one directory - it will take some reworking of internals
+> but it seems like the right design.
 
 ### show tasks in a directory
 
 ```bash
-# Logs all `*.task.ts` files in `src/lib/some/dir` and `gro/src/lib/some/dir`.
+# Logs all `*.task.ts|js` files in `src/lib/some/dir` and `gro/src/lib/some/dir`.
 # If no tasks are found, it displays an error.
 $ gro some/dir
 ```
@@ -329,7 +334,7 @@ export const task: Task = {
 
 ## why?
 
-Gro usage on the command line (`gro <taskOrDirectory> [...flags]`)
+Gro usage on the command line (`gro <task_name_or_directory> [...flags]`)
 looks a lot like using `node`.
 What makes Gro different?
 
@@ -337,14 +342,15 @@ What makes Gro different?
   contains task modules that conform to some interface.
   This allows them to be discoverable by convention,
   so running `gro` displays them all without any config, and it puts generic handles on them,
-  enabling various verbs (e.g. `run`) and structured metadata (e.g. `summary`).
-- Tasks aren't just a script, they can be inspected, composed, and manipulated in code.
+  enabling various verbs (e.g. `run`) and
+  structured metadata (e.g. `summary` and args schemas for docs and validation).
+- Tasks aren't just a script on the filesystem, they can be composed and inspected in code.
   Task modules do not have any side effects when imported,
   while Node scripts just execute when imported -
-  their primary purpose is to cause side effects.
+  their primary purpose is to cause side effects, and they're limited to the filesystem API.
   This is useful in many cases - for example `gro taskname --help`
   inspects the args schema and other metadata to print help to the console,
-  and `gro` prints the `summary` property of each task it finds.
+  and `gro` prints the `summary` property of each task it discovers.
   There's lots more to explore here, like task composition
   and improved DX with new capabilities.
 - Tasks support CLI args that are validated and typesafe
@@ -353,8 +359,8 @@ What makes Gro different?
   - When a task name is given to Gro,
     it first searches `src/lib/` in the current working directory and
     falls back to searching the Gro directory.
-    This allows your code and CLI commands to use Gro's builtin tasks
-    or override or extend them without changing how you invoke them.
+    This allows your code and CLI commands to compose Gro's builtin tasks
+    or override them without changing how you invoke them.
     Gro reserves no special behavior for its own commands -
     `gro test`, `gro gen`, and all the rest are just tasks that all follow the same rules.
     (see its task at [`src/lib/test.task.ts`](/src/lib/test.task.ts)).

package/dist/docs/tasks.gen.md.js

@@ -4,7 +4,7 @@ import { strip_start } from '@ryanatkn/belt/string.js';
 import { to_output_file_name } from '../gen.js';
 import { paths, base_path_to_source_id } from '../paths.js';
 import { load_task_modules } from '../task_module.js';
-import { log_error_reasons } from '../print_task.js';
+import { log_error_reasons } from '../task_logging.js';
 // This is the first simple implementation of Gro's automated docs.
 // It combines Gro's gen and task systems
 // to generate a markdown file describing all of the project's tasks.
@@ -14,14 +14,13 @@ import { log_error_reasons } from '../print_task.js';
 // TODO display more info about each task, including a summary and params
 // TODO needs some cleanup and better APIs - paths are confusing and verbose!
 // TODO add backlinks to every document that links to this one
-export const gen = async ({ origin_id, log }) => {
-    const result = await load_task_modules();
+export const gen = async ({ config, origin_id, log }) => {
+    const result = await load_task_modules([paths.lib], config.task_root_paths);
     if (!result.ok) {
         log_error_reasons(log, result.reasons);
         throw new Error(result.type);
     }
     const tasks = result.modules;
-    // TODO need to get this from project config or something
     const root_path = parse_path_segments(paths.root).at(-1);
     const origin_dir = dirname(origin_id);
     const origin_base = basename(origin_id);

package/dist/esbuild_plugin_external_worker.js

@@ -1,6 +1,5 @@
 import * as esbuild from 'esbuild';
 import { basename } from 'node:path';
-import { cwd } from 'node:process';
 import { print_build_result, to_define_import_meta_env } from './esbuild_helpers.js';
 import { resolve_specifier } from './resolve_specifier.js';
 import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_shim_alias.js';
@@ -8,7 +7,7 @@ import { esbuild_plugin_sveltekit_shim_env } from './esbuild_plugin_sveltekit_sh
 import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
 import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
 import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
-export const esbuild_plugin_external_worker = ({ dev, build_options, dir = cwd(), svelte_compile_options, svelte_preprocessors, svelte_compile_module_options, alias, base_url, assets_url, public_prefix, private_prefix, env_dir, env_files, ambient_env, log, }) => ({
+export const esbuild_plugin_external_worker = ({ dev, build_options, dir = process.cwd(), svelte_compile_options, svelte_preprocessors, svelte_compile_module_options, alias, base_url, assets_url, public_prefix, private_prefix, env_dir, env_files, ambient_env, log, }) => ({
     name: 'external_worker',
     setup: (build) => {
         const builds = new Map();

package/dist/esbuild_plugin_svelte.js

@@ -1,10 +1,9 @@
 import { compile, compileModule, preprocess, } from 'svelte/compiler';
 import { readFile } from 'node:fs/promises';
 import { relative } from 'node:path';
-import { cwd } from 'node:process';
 import { SVELTE_MATCHER, SVELTE_RUNES_MATCHER } from './svelte_helpers.js';
 export const esbuild_plugin_svelte = (options = {}) => {
-    const { dir = cwd(), svelte_compile_options = {}, svelte_compile_module_options = {}, svelte_preprocessors, } = options;
+    const { dir = process.cwd(), svelte_compile_options = {}, svelte_compile_module_options = {}, svelte_preprocessors, } = options;
     return {
         name: 'svelte',
         setup: (build) => {

package/dist/esbuild_plugin_sveltekit_shim_alias.js

@@ -1,7 +1,6 @@
 import { escape_regexp } from '@ryanatkn/belt/regexp.js';
-import { cwd } from 'node:process';
 import { join } from 'node:path';
-export const esbuild_plugin_sveltekit_shim_alias = ({ dir = cwd(), alias, }) => ({
+export const esbuild_plugin_sveltekit_shim_alias = ({ dir = process.cwd(), alias, }) => ({
     name: 'sveltekit_shim_alias',
     setup: (build) => {
         const aliases = { $lib: 'src/lib', ...alias };

package/dist/format_directory.js

@@ -1,10 +1,11 @@
 import { spawn } from '@ryanatkn/belt/process.js';
-import { GITHUB_DIRNAME, paths, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, CONFIG_PATH, } from './paths.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';
 const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
 const DEFAULT_ROOT_PATHS = `${[
     README_FILENAME,
-    CONFIG_PATH,
+    GRO_CONFIG_PATH,
     SVELTEKIT_CONFIG_FILENAME,
     VITE_CONFIG_FILENAME,
     TSCONFIG_FILENAME,

package/dist/gen.d.ts

@@ -1,5 +1,6 @@
 import type { Logger } from '@ryanatkn/belt/log.js';
 import { z } from 'zod';
+import type { Gro_Config } from './config.js';
 export type Gen_Result = {
     origin_id: string;
     files: Gen_File[];
@@ -14,6 +15,10 @@ export interface Gen {
     (ctx: Gen_Context): Raw_Gen_Result | Promise<Raw_Gen_Result>;
 }
 export interface Gen_Context {
+    config: Gro_Config;
+    /**
+     * Same as `import.meta.url` but in path form.
+     */
     origin_id: string;
     log: Logger;
 }

package/dist/gen.task.js

@@ -7,14 +7,14 @@ 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 { resolve_input_paths } from './input_path.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 { print_path } from './paths.js';
-import { log_error_reasons } from './print_task.js';
+import { paths, print_path } from './paths.js';
+import { log_error_reasons } from './task_logging.js';
 export const Args = z
     .object({
-    _: z.array(z.string(), { description: 'paths to generate' }).default([]),
+    _: z.array(Raw_Input_Path, { description: 'paths to generate' }).default([]),
     check: z
         .boolean({ description: 'exit with a nonzero code if any files need to be generated' })
         .default(false),
@@ -25,10 +25,9 @@ export const Args = z
 export const task = {
     summary: 'run code generation scripts',
     Args,
-    run: async ({ args, log, timings }) => {
+    run: async ({ args, log, timings, config }) => {
         const { _: raw_input_paths, check } = args;
-        // resolve the input paths relative to src/lib/
-        const input_paths = resolve_input_paths(raw_input_paths);
+        const input_paths = raw_input_paths.length ? to_input_paths(raw_input_paths) : [paths.source];
         // load all of the gen modules
         const find_modules_result = await find_gen_modules(input_paths);
         if (!find_modules_result.ok) {
@@ -49,7 +48,7 @@ export const task = {
         }
         // run `gen` on each of the modules
         const timing_to_generate_code = timings.start('generate code'); // TODO this ignores `gen_results.elapsed` - should it return `Timings` instead?
-        const gen_results = await run_gen(load_modules_result.modules, log, timings, format_file);
+        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;
         if (check) {

package/dist/gen_module.d.ts

@@ -1,5 +1,6 @@
 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 { Input_Path } from './input_path.js';
 export declare const GEN_FILE_PATTERN_TEXT = "gen";
 export declare const GEN_FILE_PATTERN: string;
 export declare const is_gen_path: (path: string) => boolean;
@@ -43,4 +44,4 @@ export type Check_Gen_Module_Result = {
 };
 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?: string[], extensions?: string[], root_dirs?: string[]) => Promise<Find_Modules_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,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { load_module, find_modules, } from './modules.js';
-import { get_possible_source_ids } from './input_path.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';

package/dist/gro.config.default.js

@@ -1,6 +1,7 @@
-import { has_sveltekit_library, gro_plugin_sveltekit_library, } from './gro_plugin_sveltekit_library.js';
+import { gro_plugin_sveltekit_library } from './gro_plugin_sveltekit_library.js';
 import { has_server, gro_plugin_server } from './gro_plugin_server.js';
-import { has_sveltekit_app, gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { has_sveltekit_app, has_sveltekit_library } from './sveltekit_helpers.js';
 /**
  * This is the default config that's passed to `gro.config.ts`
  * if it exists in the current project, and if not, this is the final config.

package/dist/gro_helpers.js

@@ -3,7 +3,12 @@ import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from '@ryanatkn/belt/process.js';
 import { exists } from './fs.js';
-import { NODE_MODULES_DIRNAME } from './paths.js';
+import { NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './path_constants.js';
+/*
+
+This module is intended to have minimal dependencies to avoid over-imports in the CLI.
+
+*/
 /**
  * Resolves a path to an internal Gro file.
  * Prefers any local installation of Gro and falls back to the current CLI context.
@@ -40,26 +45,22 @@ import { NODE_MODULES_DIRNAME } from './paths.js';
  */
 export const resolve_gro_module_path = async (path = '') => {
     const gro_bin_path = resolve(NODE_MODULES_DIRNAME, '.bin/gro');
+    // case 1
+    // Prefer any locally installed version of Gro.
     if (await exists(gro_bin_path)) {
-        // case 1
-        // Prefer any locally installed version of Gro.
         return join(await realpath(gro_bin_path), '..', path);
     }
-    else {
-        // case 2
-        // If running Gro inside its own repo, require the local dist.
-        // If the local dist is not yet built it will fall back to the global.
-        const file_path = fileURLToPath(import.meta.url);
-        const base_path = 'dist';
-        if ((await exists(join(base_path, 'gro.js'))) && (await exists(join(base_path, path)))) {
-            return join(file_path, '../..', base_path, path);
-        }
-        else {
-            // case 3
-            // Fall back to the version associated with the running CLI.
-            return join(file_path, '..', path);
-        }
+    // case 2
+    // If running Gro inside its own repo, require the local dist.
+    // If the local dist is not yet built it will fall back to the global.
+    if ((await exists(join(SVELTEKIT_DIST_DIRNAME, 'gro.js'))) &&
+        (await exists(join(SVELTEKIT_DIST_DIRNAME, path)))) {
+        return resolve(SVELTEKIT_DIST_DIRNAME, path);
     }
+    // case 3
+    // Fall back to the version associated with the running CLI.
+    const file_path = fileURLToPath(import.meta.url);
+    return join(file_path, '..', path);
 };
 /**
  * Runs a file using the Gro loader.