march-hare 0.13.0 → 0.13.1

package/README.md

@@ -27,8 +27,9 @@
 1. [Multicast actions](#multicast-actions)
 1. [Global data](#global-data)
 1. [Reusable components](#reusable-components)
+1. [Scaffolding CLI](#scaffolding-cli)
 
-For advanced topics, see the [recipes directory](./recipes/). For a worked end-to-end example with the FSD layout, see [`src/example/`](./src/example/README.md).
+For advanced topics, see the [recipes directory](./recipes/). For a worked end-to-end example with the FSD layout, see [`src/example/`](./src/example/README.md). To scaffold a new project that mirrors that example, see [`src/cli/`](./src/cli/README.md).
 
 ## Benefits
 
@@ -896,3 +897,26 @@ function Where(): React.ReactElement {
 When a reusable component or resource is genuinely Env-agnostic &mdash; the fetcher never touches `context.env`, the hook never calls `shared.useEnv` &mdash; pass `Envless` as `E` instead of spelling out `Record<never, never>`: `shared.Resource<Envless, T>`, `shared.useContext<Envless, M, A>()`. It's a named alias for the empty-record shape exported from `march-hare`, kept around purely for legibility at the call site.
 
 For one-line handler binding &mdash; flipping a boolean, assigning a payload to a leaf, pinning a field to a fixed value &mdash; reach for `context.with.{update,invert,always}`. See the [`With` helpers recipe](./recipes/with-helpers.md) for the full surface.
+
+## Scaffolding CLI
+
+A [Hygen](https://github.com/jondot/hygen)-style scaffolder ships under [`src/cli/`](./src/cli/) as the `mh` binary. It mirrors the layout of [`src/example/`](./src/example/) and the FSD layering rules enforced by `eslint-plugin-boundaries` &mdash; imports flow strictly downward (`app → features → shared`).
+
+```bash
+cd src/cli
+npm install
+npm link          # creates the global `mh` binary
+```
+
+Run it with no arguments for an interactive menu, or drive any leaf command directly:
+
+```bash
+mh                            # banner + interactive menu
+mh init my-project            # bootstrap a new project
+mh feature new add-cat        # add a stateful feature
+mh app new dashboard          # add a page
+mh shared component card      # add a shared component
+mh feature action counter Reset   # inject an Action + handler stub
+```
+
+Every command lives in a tree &mdash; typing `mh feature` opens a sub-menu, typing `mh feature new` prompts for a name, typing `mh feature new add-cat` runs non-interactively. See [`src/cli/README.md`](./src/cli/README.md) for the full command surface, the template format, and instructions for adding your own generators.

package/dist/action/index.d.ts

@@ -1,5 +1,5 @@
-import { HandlerPayload, BroadcastPayload, MulticastPayload, Distribution, Filter } from '../types/index';
-export { getActionSymbol, getLifecycleType, isBroadcastAction, isMulticastAction, getName, isChanneledAction, } from './utils';
+import { HandlerPayload, BroadcastPayload, MulticastPayload, Distribution, Filter } from '../types/index.js';
+export { getActionSymbol, getLifecycleType, isBroadcastAction, isMulticastAction, getName, isChanneledAction, } from './utils.js';
 /**
  * Interface for the Action factory function.
  */

package/dist/action/utils.d.ts

@@ -1,5 +1,5 @@
-import { ChanneledAction, AnyAction } from '../types/index';
-import { ActionId } from '../boundary/components/tasks/types';
+import { ChanneledAction, AnyAction } from '../types/index.js';
+import { ActionId } from '../boundary/components/tasks/types.js';
 /**
  * Extracts the underlying symbol from an action or channeled action.
  * This symbol is used as the event emitter key for dispatching.

package/dist/actions/index.d.ts

@@ -1,5 +1,5 @@
-import { Data } from './types';
-import { Model, Props, Actions, UseActions } from '../types/index';
+import { Data } from './types.js';
+import { Model, Props, Actions, UseActions } from '../types/index.js';
 /**
  * A hook for managing state with actions.
  *

package/dist/actions/types.d.ts

@@ -1,8 +1,8 @@
 import { default as EventEmitter } from 'eventemitter3';
 import { RefObject } from 'react';
-import { Model, HandlerContext, Actions, Props, Tasks, ActionId, Phase, Filter } from '../types/index';
-import { BroadcastEmitter } from '../boundary/components/broadcast/utils';
-import { ScopeContext } from '../boundary/components/scope/types';
+import { Model, HandlerContext, Actions, Props, Tasks, ActionId, Phase, Filter } from '../types/index.js';
+import { BroadcastEmitter } from '../boundary/components/broadcast/utils.js';
+import { ScopeContext } from '../boundary/components/scope/types.js';
 /**
  * Function signature for action handlers registered via `useAction`.
  * Receives the reactive context and payload, returning void or a promise/generator.

package/dist/actions/utils.d.ts

@@ -1,8 +1,8 @@
 import { RefObject } from 'react';
-import { Props, Model, Actions, Filter, ActionId, HandlerPayload, ChanneledAction, HandlerContext } from '../types/index';
+import { Props, Model, Actions, Filter, ActionId, HandlerPayload, ChanneledAction, HandlerContext } from '../types/index.js';
 import { default as EventEmitter } from 'eventemitter3';
-import { Dispatchers, LifecycleConfig, Scope } from './types';
-import { isChanneledAction, getActionSymbol } from '../action/index';
+import { Dispatchers, LifecycleConfig, Scope } from './types.js';
+import { isChanneledAction, getActionSymbol } from '../action/index.js';
 import * as React from "react";
 /**
  * Creates a new object with getters for each property of the input object.

package/dist/app/index.d.ts

@@ -1,10 +1,10 @@
-import { Env } from '../boundary/components/env/index';
-import { Cache } from '../cache/index';
-import { Actions, Model, Props } from '../types/index';
-import { AppHandle, AppContextHandle } from './types';
-import { Tap } from '../boundary/components/tap/types';
-export type { AppArgs, AppContextHandle, AppFetcher, AppResource, } from './types';
-export type { AppHandle } from './types';
+import { Env } from '../boundary/components/env/types.js';
+import { Cache } from '../cache/index.js';
+import { Actions, Model, Props } from '../types/index.js';
+import { AppHandle, AppContextHandle } from './types.js';
+import { Tap } from '../boundary/components/tap/types.js';
+export type { AppArgs, AppContextHandle, AppFetcher, AppResource, } from './types.js';
+export type { AppHandle } from './types.js';
 /**
  * Creates an `App` — the entrypoint for a typed Env shape `E`,
  * inferred from `config.env`. `App<E>` exposes `Boundary`, hooks, and

package/dist/app/types.d.ts

@@ -1,8 +1,8 @@
-import { Args, ResourceHandle } from '../resource/types';
-import { Actions, Context, Model, Props, UseActions } from '../types/index';
-import { Data } from '../actions/types';
-import { Env } from '../boundary/components/env/index';
-import { WithHandle } from '../with/types';
+import { Args, ResourceHandle } from '../resource/types.js';
+import { Actions, Context, Model, Props, UseActions } from '../types/index.js';
+import { Data } from '../actions/types.js';
+import { Env } from '../boundary/components/env/types.js';
+import { WithHandle } from '../with/types.js';
 /**
  * Args object passed to an `app.Resource` fetcher. Same shape as the
  * base `Resource` fetcher's args but with `env` typed as `E`.

package/dist/boundary/components/broadcast/index.d.ts

@@ -1,6 +1,6 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export { useBroadcast, BroadcastEmitter } from './utils';
+export { useBroadcast, BroadcastEmitter } from './utils.js';
 /**
  * Creates a new broadcast context for distributed actions. Only needed if you
  * want to isolate a broadcast context, useful for libraries that want to provide

package/dist/boundary/components/broadcast/types.d.ts

@@ -1,4 +1,4 @@
-import { BroadcastEmitter } from './utils';
+import { BroadcastEmitter } from './utils.js';
 import * as React from "react";
 /**
  * The broadcast context is a BroadcastEmitter used for distributed actions across components.

package/dist/boundary/components/consumer/components/partition/index.d.ts

@@ -1,4 +1,4 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
 /**
  * Renders output for the `stream()` method by subscribing to distributed action events.

package/dist/boundary/components/consumer/components/partition/types.d.ts

@@ -1,4 +1,4 @@
-import { ConsumerRenderer } from '../../types';
+import { ConsumerRenderer } from '../../types.js';
 /**
  * Props for the Partition component.
  * @internal

package/dist/boundary/components/consumer/index.d.ts

@@ -1,9 +1,9 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export { useConsumer } from './utils';
-export { Partition } from './components/partition/index';
-export type { Props as PartitionProps } from './components/partition/types';
-export type { ConsumerRenderer, Entry, ConsumerContext } from './types';
+export { useConsumer } from './utils.js';
+export { Partition } from './components/partition/index.js';
+export type { Props as PartitionProps } from './components/partition/types.js';
+export type { ConsumerRenderer, Entry, ConsumerContext } from './types.js';
 /**
  * Creates a new consumer context for storing distributed action values. Only needed if you
  * want to isolate a consumer context, useful for libraries that want to provide

package/dist/boundary/components/consumer/types.d.ts

@@ -1,5 +1,5 @@
 import { Inspect, State } from 'immertation';
-import { ActionId } from '../tasks/types';
+import { ActionId } from '../tasks/types.js';
 import * as React from "react";
 /**
  * Callback function for the stream() method.

package/dist/boundary/components/consumer/utils.d.ts

@@ -1,4 +1,4 @@
-import { ConsumerContext } from './types';
+import { ConsumerContext } from './types.js';
 import * as React from "react";
 /**
  * React context for the consumer store.

package/dist/boundary/components/env/index.d.ts

@@ -1,32 +1,8 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export { useEnv } from './utils';
+export { useEnv } from './utils.js';
 /**
- * Loose runtime shape for the per-`<Boundary>` Env. Each {@link App}
- * narrows this to its own typed env via `App<E>({ env })`; the
- * loose type exists so the framework's internal plumbing
- * (`<Boundary>`, `useEnv`, handler `context.env`, Resource
- * fetcher `context.env`) does not need to be parametric over E.
- *
- * Consumers should declare their Env shape inline via `App({ env })`
- * &mdash; the inferred `E` is what flows through `app.useContext`,
- * `app.useEnv`, and `app.Resource`. Module augmentation of `Env`
- * is no longer required.
- */
-export type Env = Record<string, unknown>;
-/**
- * `E` generic for `shared.X<E, ...>` factories whose callers don't read
- * anything off the Env. Equivalent to `Record<never, never>` &mdash; the
- * named alias keeps consumer sites legible (`shared.Resource<Envless, T>`
- * over `shared.Resource<Record<never, never>, T>`) and signals intent.
- *
- * Reach for `Envless` only when the component or resource is genuinely
- * Env-agnostic. Anything that reads `context.env.x` should declare the
- * required shape (or a union of host Envs) as `E` instead.
- */
-export type Envless = Record<never, never>;
-/**
- * Provides a per-Boundary {@link Env} value to every component inside
+ * Provides a per-Boundary {@link EnvType} value to every component inside
  * the boundary. Usually wired in via the `<Boundary env={initial}>`
  * prop rather than used directly.
  *

package/dist/boundary/components/env/types.d.ts

@@ -1,6 +1,28 @@
 import { ReactNode } from 'react';
-import { Env } from './index';
-export type { Env } from './index';
+/**
+ * Loose runtime shape for the per-`<Boundary>` Env. Each {@link App}
+ * narrows this to its own typed env via `App<E>({ env })`; the
+ * loose type exists so the framework's internal plumbing
+ * (`<Boundary>`, `useEnv`, handler `context.env`, Resource
+ * fetcher `context.env`) does not need to be parametric over E.
+ *
+ * Consumers should declare their Env shape inline via `App({ env })`
+ * &mdash; the inferred `E` is what flows through `app.useContext`,
+ * `app.useEnv`, and `app.Resource`. Module augmentation of `Env`
+ * is no longer required.
+ */
+export type Env = Record<string, unknown>;
+/**
+ * `E` generic for `shared.X<E, ...>` factories whose callers don't read
+ * anything off the Env. Equivalent to `Record<never, never>` &mdash; the
+ * named alias keeps consumer sites legible (`shared.Resource<Envless, T>`
+ * over `shared.Resource<Record<never, never>, T>`) and signals intent.
+ *
+ * Reach for `Envless` only when the component or resource is genuinely
+ * Env-agnostic. Anything that reads `context.env.x` should declare the
+ * required shape (or a union of host Envs) as `E` instead.
+ */
+export type Envless = Record<never, never>;
 /**
  * Props for the Env provider component. Accepts the initial Env
  * value that satisfies the augmented {@link Env} interface.

package/dist/boundary/components/env/utils.d.ts

@@ -1,5 +1,5 @@
 import { RefObject } from 'react';
-import { Env } from './index';
+import { Env } from './types.js';
 import * as React from "react";
 /**
  * React context exposing the per-Boundary Env ref. The ref itself is

package/dist/boundary/components/scope/index.d.ts

@@ -1,2 +1,2 @@
-export { Context, useScope, getScope } from './utils';
-export type { ScopeEntry, ScopeContext } from './types';
+export { Context, useScope, getScope } from './utils.js';
+export type { ScopeEntry, ScopeContext } from './types.js';

package/dist/boundary/components/scope/types.d.ts

@@ -1,4 +1,4 @@
-import { BroadcastEmitter } from '../broadcast/utils';
+import { BroadcastEmitter } from '../broadcast/utils.js';
 /**
  * Runtime entry for a single multicast scope opened by an
  * `<app.Scope().Boundary>`. The `id` uniquely identifies this scope

package/dist/boundary/components/scope/utils.d.ts

@@ -1,4 +1,4 @@
-import { ScopeContext, ScopeEntry } from './types';
+import { ScopeContext, ScopeEntry } from './types.js';
 import * as React from "react";
 /**
  * React context for the nearest multicast scope. `null` at the root.

package/dist/boundary/components/sharing/index.d.ts

@@ -1,4 +1,4 @@
-import { Invocation } from '../../../resource/index';
+import { Invocation } from '../../../resource/index.js';
 import * as React from "react";
 /**
  * Per-`<Boundary>` registry for `.coalesce(token)` sharing. Outer map

package/dist/boundary/components/tap/index.d.ts

@@ -1,7 +1,7 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export { useTap } from './utils';
-export type { Tap, Taps, Invocation, Failure, Mutations, Snapshot, } from './types';
+export { useTap } from './utils.js';
+export type { Tap, Taps, Invocation, Failure, Mutations, Snapshot, } from './types.js';
 /**
  * Internal provider that wires a {@link Tap} observer into the React
  * context consumed by `useActions` during dispatch. Rendered by the

package/dist/boundary/components/tap/types.d.ts

@@ -1,5 +1,5 @@
-import { Reason } from '../../../error/types';
-import { Task } from '../tasks/types';
+import { Reason } from '../../../error/types.js';
+import { Task } from '../tasks/types.js';
 import type * as React from "react";
 /**
  * Identity of a handler invocation: the action being handled and the

package/dist/boundary/components/tap/utils.d.ts

@@ -1,4 +1,4 @@
-import { Tap } from './types';
+import { Tap } from './types.js';
 import * as React from "react";
 /**
  * React context carrying the active {@link Tap} observer for the

package/dist/boundary/components/tasks/index.d.ts

@@ -1,6 +1,6 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
-export type { Task } from './types';
+export type { Task } from './types.js';
 /**
  * Creates a new tasks context for action control. Only needed if you
  * want to isolate a tasks context, useful for libraries that want to provide

package/dist/boundary/components/tasks/utils.d.ts

@@ -1,4 +1,4 @@
-import { Tasks } from './types';
+import { Tasks } from './types.js';
 import * as React from "react";
 /**
  * React context for the shared tasks Set.

package/dist/boundary/index.d.ts

@@ -1,4 +1,4 @@
-import { Props } from './types';
+import { Props } from './types.js';
 import * as React from "react";
 /**
  * Low-level boundary primitive. Wraps children with the Broadcaster,

package/dist/boundary/types.d.ts

@@ -1,5 +1,5 @@
-import { Env } from './components/env/types';
-import { Tap } from './components/tap/types';
+import { Env } from './components/env/types.js';
+import { Tap } from './components/tap/types.js';
 import type * as React from "react";
 /**
  * Props accepted by the bare `<Boundary>` provider.

package/dist/cache/index.d.ts

@@ -1,5 +1,5 @@
-import { Adapter, Stored } from './types';
-export type { Adapter, Encoded } from './types';
+import { Adapter, Stored } from './types.js';
+export type { Adapter, Encoded } from './types.js';
 /**
  * Persistence-aware cache for a single {@link Resource}. Wraps a
  * **strictly synchronous** {@link Adapter} (localStorage, MMKV,

package/dist/cache/types.d.ts

@@ -1,4 +1,4 @@
-export type { Stored } from '../utils/types';
+export type { Stored } from '../utils/types.js';
 /**
  * On-disk JSON shape of a `Stored` envelope. The Cache wrapper
  * encodes a populated Stored as `{ data, at: at.toString() }` so the

package/dist/cli/bin/mh.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { main } from "../lib/index.js";
+main(process.argv.slice(2)).catch((error) => {
+    if (error instanceof Error && error.name === "ExitPromptError") {
+        process.exit(130);
+    }
+    console.error(error);
+    process.exit(1);
+});

package/dist/cli/lib/banner/index.js

@@ -0,0 +1,14 @@
+import figlet from "figlet";
+import kleur from "kleur";
+import { config } from "../utils.js";
+export function banner() {
+    const art = figlet.textSync(config.banner.title, {
+        font: config.banner.font,
+        horizontalLayout: "default",
+        verticalLayout: "default",
+    });
+    console.log(kleur.magenta(art));
+    console.log(kleur.gray(`  ${config.banner.tagline}  `) +
+        kleur.dim(config.banner.subtitle));
+    console.log();
+}

package/dist/cli/lib/commands/app/index.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+import kleur from "kleur";
+import { pascalCase, capitalCase } from "change-case";
+import { scaffold } from "../../runner/index.js";
+import { askName, askDescription, pickDirectory, requireProjectRoot, } from "../../prompt/index.js";
+export async function newPage({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const name = positional[0] || (await askName("Page name (kebab-case)"));
+    const heading = (typeof flags.heading === "string" ? flags.heading : undefined) ||
+        capitalCase(name);
+    const tagline = (typeof flags.tagline === "string" ? flags.tagline : undefined) ||
+        (await askDescription("Page tagline", `Welcome to ${heading}`));
+    await scaffold("app", "page", { name, heading, tagline, pascalName: pascalCase(name) }, { cwd: root });
+    console.log(kleur.green("\n  Page ready."), kleur.dim(`Wire it up in src/app/index.tsx with <${pascalCase(name)}Page />.`));
+}
+export async function integration({ positional }) {
+    const root = requireProjectRoot();
+    const pagesRoot = path.join(root, "src", "app", "pages");
+    const name = positional[0] || (await pickDirectory("page", pagesRoot));
+    await scaffold("app", "integration", { name, pascalName: pascalCase(name) }, { cwd: root });
+    console.log(kleur.green("\n  Integration test added."), kleur.dim(`Run with \`make integration\` or \`npx playwright test\`.`));
+}
+export async function action({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const pagesRoot = path.join(root, "src", "app", "pages");
+    const page = positional[0] || (await pickDirectory("page", pagesRoot));
+    const name = positional[1] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Action name (PascalCase)"));
+    await scaffold("app", "action", {
+        page,
+        name: pascalCase(name),
+        pascalName: pascalCase(name),
+        rawName: name,
+    }, { cwd: root });
+    console.log(kleur.green("\n  Action added."), kleur.dim(`Dispatch with actions.dispatch(Actions.${pascalCase(name)}).`));
+}

package/dist/cli/lib/commands/feature/index.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import kleur from "kleur";
+import { pascalCase } from "change-case";
+import { scaffold } from "../../runner/index.js";
+import { askName, askConfirm, pickDirectory, requireProjectRoot, } from "../../prompt/index.js";
+async function resolveStateful(flags) {
+    if (flags.stateful !== undefined)
+        return flags.stateful !== false;
+    if (flags.presentational !== undefined)
+        return flags.presentational === false;
+    return askConfirm("Does this feature own state and actions?", true);
+}
+export async function newFeature({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const name = positional[0] || (await askName("Feature name (kebab-case)"));
+    const stateful = await resolveStateful(flags);
+    const action = stateful ? "stateful" : "presentational";
+    await scaffold("feature", action, { name, pascalName: pascalCase(name) }, { cwd: root });
+    console.log(kleur.green("\n  Feature ready."), kleur.dim(`Mount it inside a page with <${pascalCase(name)} />.`));
+}
+export async function unit({ positional }) {
+    const root = requireProjectRoot();
+    const featuresRoot = path.join(root, "src", "features");
+    const name = positional[0] || (await pickDirectory("feature", featuresRoot));
+    await scaffold("feature", "unit", { name, pascalName: pascalCase(name) }, { cwd: root });
+}
+export async function action({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const featuresRoot = path.join(root, "src", "features");
+    const feature = positional[0] || (await pickDirectory("feature", featuresRoot));
+    const name = positional[1] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Action name (PascalCase)"));
+    await scaffold("feature", "action", {
+        feature,
+        name: pascalCase(name),
+        pascalName: pascalCase(name),
+        rawName: name,
+    }, { cwd: root });
+}
+export async function multicast({ positional, flags, }) {
+    const root = requireProjectRoot();
+    const featuresRoot = path.join(root, "src", "features");
+    const feature = positional[0] || (await pickDirectory("feature", featuresRoot));
+    const name = positional[1] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Multicast action (PascalCase)"));
+    await scaffold("feature", "multicast", {
+        feature,
+        featurePascal: pascalCase(feature),
+        name: pascalCase(name),
+        pascalName: pascalCase(name),
+        rawName: name,
+    }, { cwd: root });
+}

package/dist/cli/lib/commands/index.js

@@ -0,0 +1,89 @@
+import * as init from "./init/index.js";
+import * as app from "./app/index.js";
+import * as feature from "./feature/index.js";
+import * as shared from "./shared/index.js";
+export const tree = {
+    init: {
+        leaf: true,
+        description: "Bootstrap a new March Hare project",
+        run: init.run,
+    },
+    app: {
+        leaf: false,
+        description: "Manage the host (pages, integration tests, actions)",
+        children: {
+            new: {
+                leaf: true,
+                description: "Create a new page under app/pages/",
+                run: app.newPage,
+            },
+            integration: {
+                leaf: true,
+                description: "Add an integration test for an existing page",
+                run: app.integration,
+            },
+            action: {
+                leaf: true,
+                description: "Add a new action handler to an existing page",
+                run: app.action,
+            },
+        },
+    },
+    feature: {
+        leaf: false,
+        description: "Manage features (slices, unit tests, actions)",
+        children: {
+            new: {
+                leaf: true,
+                description: "Create a new feature slice",
+                run: feature.newFeature,
+            },
+            unit: {
+                leaf: true,
+                description: "Add a unit test next to an existing feature",
+                run: feature.unit,
+            },
+            action: {
+                leaf: true,
+                description: "Add a new action handler to an existing feature",
+                run: feature.action,
+            },
+            multicast: {
+                leaf: true,
+                description: "Add a multicast action to an existing feature's Scope",
+                run: feature.multicast,
+            },
+        },
+    },
+    shared: {
+        leaf: false,
+        description: "Manage shared building blocks",
+        children: {
+            component: {
+                leaf: true,
+                description: "Create a new shared component",
+                run: shared.component,
+            },
+            resource: {
+                leaf: true,
+                description: "Create a new shared resource",
+                run: shared.resource,
+            },
+            util: {
+                leaf: true,
+                description: "Create a new shared utility",
+                run: shared.util,
+            },
+            type: {
+                leaf: true,
+                description: "Add a shared type/payload/broadcast namespace",
+                run: shared.type,
+            },
+            unit: {
+                leaf: true,
+                description: "Add a unit test next to an existing shared module",
+                run: shared.unit,
+            },
+        },
+    },
+};

package/dist/cli/lib/commands/init/index.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import process from "node:process";
+import kleur from "kleur";
+import { pascalCase } from "change-case";
+import { scaffold } from "../../runner/index.js";
+import { askName, askDescription } from "../../prompt/index.js";
+export async function run({ positional, flags }) {
+    const rawName = positional[0] ||
+        (typeof flags.name === "string" ? flags.name : undefined) ||
+        (await askName("Project name", "my-app"));
+    const description = (typeof flags.description === "string" ? flags.description : undefined) ||
+        (await askDescription("Short description", `A March Hare project: ${rawName}`));
+    const apiBase = (typeof flags.apiBase === "string" ? flags.apiBase : undefined) ||
+        (await askDescription("Default API base URL", "https://api.example.com"));
+    const cwd = path.resolve(process.cwd(), rawName);
+    const env = pascalCase(rawName);
+    console.log();
+    console.log(kleur.bold(`  Scaffolding ${kleur.magenta(rawName)} into ${kleur.gray(cwd)}`));
+    console.log();
+    await scaffold("init", "new", { name: rawName, description, apiBase, env }, { cwd });
+    console.log();
+    console.log(kleur.green("  Project ready."));
+    console.log();
+    console.log(kleur.bold("  Next steps:"));
+    console.log(`    cd ${rawName}`);
+    console.log("    yarn install");
+    console.log("    yarn dev");
+    console.log();
+}