domain-driver 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # domain-driver 🚀
 
-A CLI scaffolding tool for domain-driven development in Next.js. Generate feature folder structures instantly — like Laravel's `php artisan make` but for Next.js.
+A CLI scaffolding tool for domain-driven feature folders. Like Laravel's `php artisan make`, but for Next.js, React, Node, and NestJS projects. It detects your stack and generates only the layers that stack needs, one file per action.
 
 ---
 
@@ -13,249 +13,263 @@ npm install -g domain-driver
 Or use without installing:
 
 ```bash
-npx domain-driver make:feature <n>
+npx domain-driver make:feature <feature>[/<Entity>]
 ```
 
 ---
 
-## Commands
-
-### `make:feature`
+## Stack detection
 
-Scaffold a full feature folder structure.
+Every command reads your `package.json` once and prints the stack it found before writing anything:
 
-```bash
-domain-driver make:feature <n>
-domain-driver make:feature <n> -a
 ```
+Stack: next-fullstack (detected)
+```
+
+| Stack | Detected when | Features live in |
+|---|---|---|
+| `nest` | `@nestjs/core` is a dependency | `src/<feature>` |
+| `next-fullstack` | `next` is a dependency and `app/api`, `src/app/api`, `pages/api`, or `src/pages/api` exists | `app/<feature>` or `src/app/<feature>` |
+| `next-frontend` | `next` is a dependency, no api directory | `app/<feature>` or `src/app/<feature>` |
+| `react` | `react` is a dependency, `next` is not | `src/features/<feature>` or `features/<feature>` |
+| `node` | none of the above | `src/features/<feature>` or `features/<feature>` |
 
-The `-a` flag scaffolds all files inside each folder automatically.
+For `node`, the tool also picks up Express, Fastify, or Hono and shapes the controllers accordingly. With none of them present it generates framework-agnostic controller classes.
+
+Override detection with `--stack`:
 
 ```bash
-domain-driver make:feature coffee-type        # folders + .gitkeep only
-domain-driver make:feature coffee-type  -a    # folders + all files
+domain-driver --stack nest make:feature cat -a
 ```
 
 ---
 
-### `make:component`
-
-Scaffold a component inside an existing feature. Defaults to `client` if no type is specified.
+## What each stack generates
 
-```bash
-domain-driver make:component <feature> <n>
-domain-driver make:component <feature> <n> client
-domain-driver make:component <feature> <n> server
-```
+| Layer | next-fullstack | next-frontend | react | node | nest |
+|---|---|---|---|---|---|
+| `page.tsx` | yes | yes | | | |
+| components | client + server | client + server | flat | | |
+| containers, hooks | yes | yes | yes | | |
+| client services + repositories (fetch) | `client/` | top level | top level | | |
+| server services + repositories (database stubs) | `server/` | | | yes | yes |
+| controllers | `app/api/<feature>/` route handlers | | | five files + routes file | five files |
+| module | | | | | yes |
+| DTOs (`nestjs-zod`) | | | | | yes |
+| schemas (Zod), types | yes | yes | yes | yes | yes |
 
-```bash
-domain-driver make:component coffee-type CoffeeTypeList
-domain-driver make:component coffee-type CoffeeTypeForm client
-domain-driver make:component coffee-type CoffeeTypeCard server
-```
+Every layer that has actions gets one file per action: `List`, `Show`, `Create`, `Update`, `Delete`. Saving a cat means `CreateCat.controller.ts`, `CreateCat.service.ts`, `CreateCat.repository.ts`, and `CreateCat.schema.ts`.
 
 ---
 
-### `make:container`
+## Commands
 
-Scaffold a smart container component inside an existing feature.
+Every layer command takes one target, `<feature>/<Name>`: the feature folder on the left, the name used inside the files on the right. `users/User` reads as "User inside users".
 
-```bash
-domain-driver make:container <feature> <n>
-```
+### `make:feature`
 
 ```bash
-domain-driver make:container coffee-type CoffeeTypeContainer
+domain-driver make:feature users            # folders + .gitkeep, plus page.tsx (Next) or the module (Nest)
+domain-driver make:feature users/User -a    # every layer for the detected stack, entity User
 ```
 
----
-
-### `make:hook`
+Feature names must be kebab-case. Without `/Entity`, the entity is the PascalCase feature name (`users` becomes `Users`).
 
-Scaffold a custom hook inside an existing feature.
+### `make:action`
 
 ```bash
-domain-driver make:hook <feature> <n>
+domain-driver make:action users/User findActiveUsers
+domain-driver make:action users/User archiveUser --with-input --returns one
 ```
 
-```bash
-domain-driver make:hook coffee-type useCoffeeType
-```
+Scaffolds a bespoke operation as its own files, so it never lands inside `ShowUser` or `ListUser`. The action name is used as-is for file and class names: `FindActiveUsers.service.ts`, `FindActiveUsersService`, handler `findActiveUsersController`, route `/find-active-users`. Include the noun in the name (`archiveUser`, not `archive`).
 
----
+| Option | Effect |
+|---|---|
+| `--with-input` | writes `ArchiveUser.schema.ts` (and the Nest DTO), the service takes `data`, the controller is a `POST` with body validation |
+| `--returns list` | `Promise<User[]>` (default) |
+| `--returns one` | `Promise<User>` |
+| `--returns void` | `Promise<void>`, controller responds 204 |
 
-### `make:service`
+| Stack | Files written |
+|---|---|
+| `node` | service, repository, controller for the detected framework, plus the line to add above the `/:id` routes in `<feature>.routes.ts` printed |
+| `nest` | injectable service and repository, `@Controller` class, DTO with input, plus the classes to register printed, with the controller listed before `Show<Entity>Controller` |
+| `next-fullstack` | server service and repository, client service and repository, `app/api/<feature>/<slug>/route.ts` |
+| `next-frontend`, `react` | client service and repository calling `/api/<feature>/<slug>` |
 
-Scaffold a set of single-responsibility service files inside an existing feature.
+### `make:controller`
 
 ```bash
-domain-driver make:service <feature> <n>
+domain-driver make:controller users/User
 ```
 
+Node: five controllers plus `<feature>.routes.ts` for Express, Fastify, or Hono. Nest: five single-action controllers. Next.js fullstack: `app/api/<feature>/route.ts` and `app/api/<feature>/[id]/route.ts`. Not available on frontend-only stacks.
+
+### `make:service` and `make:repository`
+
 ```bash
-domain-driver make:service coffee-type CoffeeType
+domain-driver make:service users/User [--side client|server|both]
+domain-driver make:repository users/User [--side client|server|both]
 ```
 
-Generates:
+`--side` matters on `next-fullstack`, where both sides exist. Default is `both`.
 
-```
-app/coffee-type/services/
-├── ListCoffeeType.service.ts
-├── ShowCoffeeType.service.ts
-├── CreateCoffeeType.service.ts
-├── UpdateCoffeeType.service.ts
-└── DeleteCoffeeType.service.ts
-```
+### `make:schema`
 
----
+```bash
+domain-driver make:schema users/User
+```
 
-### `make:repository`
+Writes `CreateUser.schema.ts` and `UpdateUser.schema.ts`. On Nest it also writes the matching DTO classes derived with `createZodDto` from `nestjs-zod`.
 
-Scaffold a set of single-responsibility repository files inside an existing feature.
+### `make:types`, `make:component`, `make:container`, `make:hook`
 
 ```bash
-domain-driver make:repository <feature> <n>
+domain-driver make:types users/User
+domain-driver make:component users/UserCard [client|server]
+domain-driver make:container users/UserContainer
+domain-driver make:hook users/useUser
 ```
 
+Component, container, and hook commands fail with a clear message on backend stacks, and `server` components are rejected on React.
+
+### `init`
+
 ```bash
-domain-driver make:repository coffee-type CoffeeType
+domain-driver init
 ```
 
-Generates:
+Writes agent guidance into the current project so coding agents scaffold with domain-driver instead of hand-writing layers:
 
-```
-app/coffee-type/repositories/
-├── ListCoffeeType.repository.ts
-├── ShowCoffeeType.repository.ts
-├── CreateCoffeeType.repository.ts
-├── UpdateCoffeeType.repository.ts
-└── DeleteCoffeeType.repository.ts
-```
+- `AGENTS.md` and `CLAUDE.md` get a section between `<!-- domain-driver:start -->` and `<!-- domain-driver:end -->`. Existing content outside the markers is never touched; the section is created, refreshed in place, or left alone.
+- `.claude/skills/domain-driver/SKILL.md` is a Claude Code skill owned by the tool.
 
----
+Running `init` twice reports `unchanged`. Re-run it after upgrading domain-driver.
 
-### `make:schema`
+**On install.** A local `npm install domain-driver` in a project runs `init` automatically. It does nothing when `CI` is set, for global installs, when there is no `package.json` in the installing project, or when domain-driver installs itself. Files are written to the directory you ran npm install from, which in a workspace is the repository root. Opt out with `npm install --ignore-scripts`, or delete the marked section afterwards.
+
+---
 
-Scaffold Zod schemas for create and update operations inside an existing feature.
+## Example: `make:feature coffee-type -a` on Node with Express
 
-```bash
-domain-driver make:schema <feature> <n>
 ```
-
-```bash
-domain-driver make:schema coffee-type CoffeeType
+src/features/coffee-type/
+├── coffee-type.routes.ts
+├── controllers/
+│   ├── ListCoffeeType.controller.ts
+│   ├── ShowCoffeeType.controller.ts
+│   ├── CreateCoffeeType.controller.ts
+│   ├── UpdateCoffeeType.controller.ts
+│   └── DeleteCoffeeType.controller.ts
+├── services/            (five files)
+├── repositories/        (five files, database-agnostic stubs)
+├── schemas/
+│   ├── CreateCoffeeType.schema.ts
+│   └── UpdateCoffeeType.schema.ts
+└── types/
+    └── CoffeeType.types.ts
 ```
 
-Generates:
+Mount the routes with `app.use('/coffee-type', coffeeTypeRoutes)`. Then `make:action coffee-type/CoffeeType findActive` adds `FindActive.controller.ts`, `FindActive.service.ts`, `FindActive.repository.ts`, and prints `router.get('/find-active', findActiveController);` for the routes file.
+
+## Example: `make:feature coffee-type -a` on NestJS
 
 ```
-app/coffee-type/schemas/
-├── CreateCoffeeType.schema.ts
-└── UpdateCoffeeType.schema.ts
+src/coffee-type/
+├── coffee-type.module.ts          registers 5 controllers and 10 providers
+├── controllers/                   five @Controller('coffee-type') classes
+├── services/                      five @Injectable() services
+├── repositories/                  five @Injectable() repositories
+├── dto/
+│   ├── CreateCoffeeType.dto.ts
+│   └── UpdateCoffeeType.dto.ts
+├── schemas/
+└── types/
 ```
 
+Install `nestjs-zod` and register `ZodValidationPipe` as `APP_PIPE` once in your `AppModule`. The tool prints this hint when the package is missing.
+
 ---
 
-## What `make:feature -a` generates
+## Philosophy
 
-Running `domain-driver make:feature coffee-type -a` creates the full structure:
+Everything for a feature lives in one folder, and every file does one thing.
 
-```
-app/
-└── coffee-type/
-    ├── components/
-    │   ├── server/
-    │   └── client/
-    │       └── CoffeeType.tsx
-    ├── containers/
-    │   └── CoffeeTypeContainer.tsx
-    ├── hooks/
-    │   └── useCoffeeType.ts
-    ├── services/
-    │   ├── ListCoffeeType.service.ts
-    │   ├── ShowCoffeeType.service.ts
-    │   ├── CreateCoffeeType.service.ts
-    │   ├── UpdateCoffeeType.service.ts
-    │   └── DeleteCoffeeType.service.ts
-    ├── repositories/
-    │   ├── ListCoffeeType.repository.ts
-    │   ├── ShowCoffeeType.repository.ts
-    │   ├── CreateCoffeeType.repository.ts
-    │   ├── UpdateCoffeeType.repository.ts
-    │   └── DeleteCoffeeType.repository.ts
-    ├── schemas/
-    │   ├── CreateCoffeeType.schema.ts
-    │   └── UpdateCoffeeType.schema.ts
-    └── page.tsx
-```
+- **repositories** — data access only. Client-side repositories call your API; server-side repositories call your database.
+- **services** — business logic, one class per action.
+- **controllers** — HTTP in, service call, HTTP out, one file per action.
+- **hooks** — React state and side effects, calls services.
+- **containers** — wire hooks into UI.
+- **components** — presentational UI.
+- **schemas** — Zod validation for create and update; the update body never carries the id, it comes from the path.
+- **types** — the entity interface.
+
+Server-side repositories throw a clear not-implemented error until you wire your ORM. Compiling code that fails loudly beats a fake store that looks like it works.
 
 ---
 
-## Philosophy
+## Updating
 
-This tool follows a strict **domain-driven** folder structure where everything related to a feature lives together. No more hunting across `/components`, `/hooks`, and `/services` top-level folders.
+Every command checks the registry at most once a day and, when a newer release exists, prints one line after its output:
 
-The layer responsibilities are:
+```
+ℹ️  domain-driver 0.3.0 is available (you have 0.2.0). Run: domain-driver update
+```
+
+```bash
+domain-driver update            # detects how it was installed, runs your package manager, refreshes the guidance
+domain-driver update --dry-run  # show the command it would run
+domain-driver update --check    # only report whether a newer version exists
+```
 
-- **repositories** — data fetching only, no business logic
-- **services** — business logic, calls repositories
-- **hooks** — React state and side effects, calls services
-- **containers** — wire hooks into UI, no direct data fetching
-- **components** — pure presentational UI, no data dependencies
-- **schemas** — Zod validation for create and update operations
+Local installs use the package manager the project uses (npm, pnpm, yarn, or bun, from the `packageManager` field or the lockfile). Global installs use `npm install -g`. Running through `npx` needs no update: `npx domain-driver@latest` always fetches the newest.
+
+The check is skipped in CI (any `CI` value other than empty, `0`, or `false`), when output is not a terminal, when `DOMAIN_DRIVER_NO_UPDATE_CHECK` is set (same value rule), or when `NO_UPDATE_NOTIFIER` is set to anything.
+
+The cache lives in `~/.cache/domain-driver` (or `$XDG_CACHE_HOME/domain-driver`); `DOMAIN_DRIVER_CACHE_DIR` overrides it.
 
 ---
 
-## Requirements
+## Upgrading from 0.1.0
 
-- Node.js 18+
+Every layer command now takes a single `<feature>/<Name>` target instead of separate feature and name arguments, for example `make:schema users User` becomes `make:schema users/User`. `make:feature users -a` still works and names the entity `Users`; write `users/User` if you want a different entity name.
 
 ---
 
-## Framework Support
+## Requirements
 
-This tool is optimised for **Next.js App Router** projects. All files are scaffolded into the `app/` directory following Next.js conventions (`page.tsx`, server/client component separation, etc.).
+- Node.js 18+
 
-If no `app/` directory exists, it will be created automatically. This means the tool can also be used in any project where an `app/<feature>` folder structure makes sense.
+---
 
 ## Local Development
 
 ```bash
-# Clone the repo
 git clone https://github.com/IsaacHatilima/domain-driver
 cd domain-driver
-
-# Install dependencies
 npm install
-
-# Build
 npm run build
-
-# Link globally for local testing
 npm link
-
-# Test it
-domain-driver make:feature test-feature
-domain-driver make:feature test-feature -a
+npm test
+npm run test:coverage
 ```
 
 ---
 
 ## Roadmap
 
-- [x] `make:feature` — scaffold feature folder structure
-- [x] `make:feature -a` — scaffold feature with all files
-- [x] `make:component` — scaffold a component
-- [x] `make:container` — scaffold a container
-- [x] `make:hook` — scaffold a custom hook
-- [x] `make:service` — scaffold single-responsibility services
-- [x] `make:repository` — scaffold single-responsibility repositories
-- [x] `make:schema` — scaffold Zod schemas
-- [ ] Interactive mode — prompt for name if not provided
-- [ ] Config file — customize folder structure per project
+- [x] Stack detection for Next.js, React, Node, and NestJS
+- [x] `make:controller` with Express, Fastify, Hono, Nest, and Next route handlers
+- [x] Per-action files in every layer
+- [x] Bespoke actions with make:action
+- [x] Agent guidance with init and a guarded postinstall
+- [ ] Config file — override stack and feature root per project
+- [ ] Configurable API base URL for client repositories
+- [ ] ORM-aware server repositories
 
 ---
 
 ## License
 
-MIT
+MIT

package/dist/cli.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCliDeps = defaultCliDeps;
+exports.createProgram = createProgram;
+// src/cli.ts
+const commander_1 = require("commander");
+const os = __importStar(require("os"));
+const action_1 = require("./commands/action");
+const component_1 = require("./commands/component");
+const container_1 = require("./commands/container");
+const controller_1 = require("./commands/controller");
+const feature_1 = require("./commands/feature");
+const hints_1 = require("./commands/hints");
+const hook_1 = require("./commands/hook");
+const repository_1 = require("./commands/repository");
+const schema_1 = require("./commands/schema");
+const service_1 = require("./commands/service");
+const sides_1 = require("./commands/sides");
+const target_1 = require("./commands/target");
+const types_1 = require("./commands/types");
+const update_1 = require("./commands/update");
+const init_1 = require("./init/init");
+const detect_1 = require("./stack/detect");
+const types_2 = require("./stack/types");
+const actions_1 = require("./templates/actions");
+const check_1 = require("./update/check");
+const registry_1 = require("./update/registry");
+const version_1 = require("./update/version");
+const SKIP_DETECTION = new Set(['init', 'update']);
+function defaultCliDeps() {
+    return {
+        env: process.env,
+        isTTY: process.stdout.isTTY === true,
+        homedir: os.homedir(),
+        now: Date.now,
+        fetchImpl: registry_1.nodeFetch,
+        current: (0, version_1.currentVersion)(),
+        updateDeps: update_1.defaultUpdateDeps,
+        log: (line) => console.log(line),
+    };
+}
+function createProgram(deps) {
+    const program = new commander_1.Command();
+    program
+        .name('domain-driver')
+        .description('CLI scaffolding tool for domain-driven feature folders in Next.js, React, Node, and NestJS projects')
+        .version(deps.current)
+        .option('--stack <name>', `Override stack detection (${types_2.STACK_NAMES.join(', ')})`);
+    let pendingNotice = Promise.resolve(null);
+    program.hook('preAction', (_thisCommand, actionCommand) => {
+        const name = actionCommand.name();
+        if ((0, check_1.shouldCheck)(deps.env, deps.isTTY, name)) {
+            pendingNotice = (0, check_1.checkForUpdate)({
+                env: deps.env,
+                homedir: deps.homedir,
+                now: deps.now,
+                fetchImpl: deps.fetchImpl,
+                current: deps.current,
+            });
+        }
+        if (SKIP_DETECTION.has(name))
+            return;
+        const { stack } = program.opts();
+        deps.log((0, detect_1.describeStack)((0, detect_1.detectStack)(stack)));
+    });
+    program.hook('postAction', async () => {
+        const notice = await pendingNotice;
+        if (notice !== null)
+            deps.log(notice);
+    });
+    program
+        .command('make:feature <target>')
+        .description('Scaffold a feature folder for the detected stack (<feature> or <feature>/<Entity>)')
+        .option('-a, --all', 'Scaffold all files inside each folder')
+        .action(async (target, options) => {
+        const { feature, entity } = (0, target_1.parseFeatureTarget)(target);
+        await (0, feature_1.makeFeature)(feature, options.all ?? false, entity ?? undefined);
+    });
+    program
+        .command('make:component <target>')
+        .description('Scaffold a component inside an existing feature (<feature>/<Name>)')
+        .argument('[type]', 'Component type: client or server', 'client')
+        .action((target, type) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        (0, component_1.makeComponent)(feature, name, (0, component_1.parseComponentType)(type));
+    });
+    program
+        .command('make:container <target>')
+        .description('Scaffold a smart container component inside an existing feature (<feature>/<Name>)')
+        .action((target) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        (0, container_1.makeContainer)(feature, name);
+    });
+    program
+        .command('make:hook <target>')
+        .description('Scaffold a custom hook inside an existing feature (<feature>/<useName>)')
+        .action((target) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        (0, hook_1.makeHook)(feature, name);
+    });
+    program
+        .command('make:service <target>')
+        .description('Scaffold single-responsibility service files inside an existing feature (<feature>/<Entity>)')
+        .option('--side <side>', 'client, server, or both', 'both')
+        .action((target, options) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        const wrote = (0, service_1.makeService)(feature, name, (0, sides_1.parseSide)(options.side));
+        if (wrote)
+            (0, hints_1.hintRegisterInModule)(feature, (0, hints_1.standardClassNames)(name, 'Service'));
+    });
+    program
+        .command('make:repository <target>')
+        .description('Scaffold single-responsibility repository files inside an existing feature (<feature>/<Entity>)')
+        .option('--side <side>', 'client, server, or both', 'both')
+        .action((target, options) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        const wrote = (0, repository_1.makeRepository)(feature, name, (0, sides_1.parseSide)(options.side));
+        if (wrote)
+            (0, hints_1.hintRegisterInModule)(feature, (0, hints_1.standardClassNames)(name, 'Repository'));
+    });
+    program
+        .command('make:controller <target>')
+        .description('Scaffold single-responsibility controllers or route handlers inside an existing feature (<feature>/<Entity>)')
+        .action((target) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        const wrote = (0, controller_1.makeController)(feature, name);
+        if (wrote)
+            (0, hints_1.hintRegisterInModule)(feature, (0, hints_1.standardClassNames)(name, 'Controller'));
+    });
+    program
+        .command('make:action <target> <action>')
+        .description('Scaffold a bespoke action as its own service, repository, and controller (<feature>/<Entity> <actionName>)')
+        .option('--with-input', 'The action takes a request body validated by a Zod schema', false)
+        .option('--returns <kind>', 'list, one, or void', 'list')
+        .action((target, action, options) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        const returns = (0, action_1.parseReturns)(options.returns);
+        const wrote = (0, action_1.makeAction)(feature, name, action, { withInput: options.withInput, returns });
+        if (wrote) {
+            const { pascal } = (0, actions_1.actionCase)(action);
+            (0, hints_1.hintRegisterInModule)(feature, [`${pascal}Controller`, `${pascal}Service`, `${pascal}Repository`], `list ${pascal}Controller before Show${name}Controller in controllers`);
+        }
+    });
+    program
+        .command('make:schema <target>')
+        .description('Scaffold Zod schemas (and Nest DTOs) for create and update operations (<feature>/<Entity>)')
+        .action((target) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        (0, schema_1.makeSchema)(feature, name);
+    });
+    program
+        .command('make:types <target>')
+        .description('Scaffold a types file inside an existing feature (<feature>/<Entity>)')
+        .action((target) => {
+        const { feature, name } = (0, target_1.parseTarget)(target);
+        (0, types_1.makeTypes)(feature, name);
+    });
+    program
+        .command('init')
+        .description('Write agent guidance into this project: AGENTS.md, CLAUDE.md, and .claude/skills/domain-driver/SKILL.md')
+        .action(() => {
+        for (const result of (0, init_1.runInit)(process.cwd())) {
+            console.log(`${init_1.INIT_ICONS[result.status]} ${result.file} ${result.status}`);
+        }
+    });
+    program
+        .command('update')
+        .description('Update domain-driver with your package manager, then refresh the agent guidance')
+        .option('--dry-run', 'Print the command without running it', false)
+        .option('--check', 'Only report whether a newer version exists', false)
+        .action(async (options) => {
+        await (0, update_1.runUpdate)(options, deps.updateDeps());
+    });
+    return program;
+}