domain-driver 0.1.0 → 0.2.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,241 @@ 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>` |
+
+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.
 
-The `-a` flag scaffolds all files inside each folder automatically.
+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`
+## What each stack generates
 
-Scaffold a component inside an existing feature. Defaults to `client` if no type is specified.
+| 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 <feature> <n>
-domain-driver make:component <feature> <n> client
-domain-driver make:component <feature> <n> server
-```
-
-```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
 ```
 
----
+Feature names must be kebab-case. Without `/Entity`, the entity is the PascalCase feature name (`users` becomes `Users`).
 
-### `make:hook`
-
-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
 ```
 
-```bash
-domain-driver make:service coffee-type CoffeeType
-```
+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.
 
-Generates:
+### `make:service` and `make:repository`
 
+```bash
+domain-driver make:service users/User [--side client|server|both]
+domain-driver make:repository users/User [--side client|server|both]
 ```
-app/coffee-type/services/
-├── ListCoffeeType.service.ts
-├── ShowCoffeeType.service.ts
-├── CreateCoffeeType.service.ts
-├── UpdateCoffeeType.service.ts
-└── DeleteCoffeeType.service.ts
-```
-
----
 
-### `make:repository`
+`--side` matters on `next-fullstack`, where both sides exist. Default is `both`.
 
-Scaffold a set of single-responsibility repository files inside an existing feature.
+### `make:schema`
 
 ```bash
-domain-driver make:repository <feature> <n>
+domain-driver make:schema users/User
 ```
 
+Writes `CreateUser.schema.ts` and `UpdateUser.schema.ts`. On Nest it also writes the matching DTO classes derived with `createZodDto` from `nestjs-zod`.
+
+### `make:types`, `make:component`, `make:container`, `make:hook`
+
 ```bash
-domain-driver make:repository coffee-type CoffeeType
+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
 ```
 
-Generates:
+Component, container, and hook commands fail with a clear message on backend stacks, and `server` components are rejected on React.
 
-```
-app/coffee-type/repositories/
-├── ListCoffeeType.repository.ts
-├── ShowCoffeeType.repository.ts
-├── CreateCoffeeType.repository.ts
-├── UpdateCoffeeType.repository.ts
-└── DeleteCoffeeType.repository.ts
+### `init`
+
+```bash
+domain-driver init
 ```
 
----
+Writes agent guidance into the current project so coding agents scaffold with domain-driver instead of hand-writing layers:
 
-### `make:schema`
+- `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.
 
-Scaffold Zod schemas for create and update operations inside an existing feature.
+Running `init` twice reports `unchanged`. Re-run it after upgrading domain-driver.
 
-```bash
-domain-driver make:schema <feature> <n>
-```
+**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.
 
-```bash
-domain-driver make:schema coffee-type CoffeeType
-```
+---
 
-Generates:
+## Example: `make:feature coffee-type -a` on Node with Express
 
 ```
-app/coffee-type/schemas/
-├── CreateCoffeeType.schema.ts
-└── UpdateCoffeeType.schema.ts
+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
 ```
 
----
-
-## What `make:feature -a` 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.
 
-Running `domain-driver make:feature coffee-type -a` creates the full structure:
+## Example: `make:feature coffee-type -a` on NestJS
 
 ```
-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
+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.
+
 ---
 
 ## Philosophy
 
-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.
+Everything for a feature lives in one folder, and every file does one thing.
 
-The layer responsibilities are:
+- **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.
 
-- **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
+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.
 
 ---
 
-## 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/commands/action.js

@@ -0,0 +1,118 @@
+"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.parseReturns = parseReturns;
+exports.makeAction = makeAction;
+const path = __importStar(require("path"));
+const registry_1 = require("../stack/registry");
+const actions_1 = require("../templates/actions");
+const server_repository_1 = require("../templates/backend/server-repository");
+const nest_1 = require("../templates/controllers/nest");
+const next_action_route_1 = require("../templates/controllers/next-action-route");
+const node_1 = require("../templates/controllers/node");
+const client_repository_1 = require("../templates/frontend/client-repository");
+const dto_1 = require("../templates/nest/dto");
+const service_1 = require("../templates/service");
+const schema_1 = require("../templates/shared/schema");
+const fs_1 = require("../utils/fs");
+const naming_1 = require("../utils/naming");
+const paths_1 = require("../utils/paths");
+const hints_1 = require("./hints");
+const resolve_1 = require("./resolve");
+const write_1 = require("./write");
+function parseReturns(value) {
+    if (actions_1.RETURN_KINDS.includes(value))
+        return value;
+    throw new Error(`Invalid --returns "${value}". Use list, one, or void.`);
+}
+function makeAction(feature, entity, actionName, options) {
+    const ctx = (0, resolve_1.requireFeature)(feature);
+    const spec = (0, actions_1.customAction)(entity, actionName, options);
+    hintMissingTypes(ctx, entity);
+    let wroteAny = false;
+    if (spec.schema !== null)
+        wroteAny = writeInput(ctx, spec) || wroteAny;
+    if ((0, registry_1.hasLayer)(ctx.profile, 'serverRepository'))
+        wroteAny = writeSide(ctx, spec, entity, 'server') || wroteAny;
+    if ((0, registry_1.hasLayer)(ctx.profile, 'controller'))
+        wroteAny = writeController(ctx, spec, entity) || wroteAny;
+    if ((0, registry_1.hasLayer)(ctx.profile, 'clientRepository'))
+        wroteAny = writeSide(ctx, spec, entity, 'client') || wroteAny;
+    if (wroteAny)
+        console.log(`✅ Action "${spec.name}" scaffolded in "${feature}"`);
+    return wroteAny;
+}
+function hintMissingTypes(ctx, entity) {
+    const typesFile = path.join(ctx.featureDir, (0, registry_1.layerDir)(ctx.profile, 'types'), `${entity}.types.ts`);
+    if ((0, fs_1.fileExists)(typesFile))
+        return;
+    console.log(`ℹ️  types/${entity}.types.ts not found. Run: domain-driver make:types ${ctx.feature}/${entity}`);
+}
+function writeInput(ctx, spec) {
+    const schemaFile = path.join((0, resolve_1.ensureLayerDir)(ctx, 'schema'), `${spec.name}.schema.ts`);
+    const wroteSchema = (0, write_1.writeIfAbsent)(schemaFile, () => (0, schema_1.renderSchema)(spec.name, (0, naming_1.lowerFirst)(spec.name)));
+    if (!(0, registry_1.hasLayer)(ctx.profile, 'dto'))
+        return wroteSchema;
+    const dtoFile = path.join((0, resolve_1.ensureLayerDir)(ctx, 'dto'), `${spec.name}.dto.ts`);
+    const wroteDto = (0, write_1.writeIfAbsent)(dtoFile, () => (0, dto_1.renderDto)(ctx, spec.name, dtoFile));
+    (0, hints_1.hintNestjsZod)(ctx.stack);
+    return wroteSchema || wroteDto;
+}
+function writeSide(ctx, spec, entity, side) {
+    const repositoryLayer = side === 'client' ? 'clientRepository' : 'serverRepository';
+    const serviceLayer = side === 'client' ? 'clientService' : 'serverService';
+    const renderRepository = side === 'client' ? client_repository_1.renderClientRepository : server_repository_1.renderServerRepository;
+    const repositoryFile = path.join((0, resolve_1.ensureLayerDir)(ctx, repositoryLayer), `${spec.name}.repository.ts`);
+    const wroteRepository = (0, write_1.writeIfAbsent)(repositoryFile, () => renderRepository(ctx, spec, entity, repositoryFile));
+    const serviceFile = path.join((0, resolve_1.ensureLayerDir)(ctx, serviceLayer), `${spec.name}.service.ts`);
+    const wroteService = (0, write_1.writeIfAbsent)(serviceFile, () => (0, service_1.renderService)(ctx, spec, entity, serviceFile, side));
+    return wroteRepository || wroteService;
+}
+function writeController(ctx, spec, entity) {
+    if (ctx.profile.name === 'next-fullstack') {
+        const routeDir = path.join((0, paths_1.apiRouteDir)(ctx.stack, ctx.feature), spec.path.slice(1));
+        (0, fs_1.mkdirSafe)(routeDir);
+        const routeFile = path.join(routeDir, 'route.ts');
+        return (0, write_1.writeIfAbsent)(routeFile, () => (0, next_action_route_1.renderActionRoute)(ctx, spec, routeFile));
+    }
+    const controllerFile = path.join((0, resolve_1.ensureLayerDir)(ctx, 'controller'), `${spec.name}.controller.ts`);
+    const render = ctx.profile.name === 'nest' ? nest_1.renderNestController : node_1.renderNodeController;
+    const wroteController = (0, write_1.writeIfAbsent)(controllerFile, () => render(ctx, spec, entity, controllerFile));
+    const line = ctx.profile.name === 'node' ? (0, node_1.renderNodeRouteLine)(ctx, spec, entity) : null;
+    if (wroteController && line !== null) {
+        console.log(`ℹ️  Add to ${ctx.feature}.routes.ts above the '/:id' routes: ${line}`);
+    }
+    return wroteController;
+}

package/dist/commands/component.js

@@ -33,30 +33,29 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseComponentType = parseComponentType;
 exports.makeComponent = makeComponent;
 const path = __importStar(require("path"));
-const utils_1 = require("../utils");
-function renderComponent(name, type) {
-    const directive = type === 'client' ? "'use client';\n\n" : '';
-    return `${directive}interface ${name}Props {
-  id: string;
-}
-
-export default function ${name}({ id }: ${name}Props) {
-  return (
-    <div>
-      <h1>${name}</h1>
-    </div>
-  );
-}
-`;
+const registry_1 = require("../stack/registry");
+const component_1 = require("../templates/frontend/component");
+const fs_1 = require("../utils/fs");
+const resolve_1 = require("./resolve");
+function parseComponentType(value) {
+    return value === 'server' ? 'server' : 'client';
 }
 function makeComponent(feature, name, type = 'client') {
-    const base = (0, utils_1.ensureFeatureExists)(feature, `components/${type}`);
-    const filePath = path.join(base, `${name}.tsx`);
-    if ((0, utils_1.fileExists)(filePath)) {
+    const ctx = (0, resolve_1.requireFeature)(feature);
+    (0, registry_1.assertLayer)(ctx.profile, 'component', 'make:component');
+    if (type === 'server' && !ctx.profile.serverComponents) {
+        throw new Error(`The ${ctx.profile.name} stack has no server components.`);
+    }
+    const dir = path.join(ctx.featureDir, (0, registry_1.componentDir)(ctx.profile, type));
+    (0, fs_1.mkdirSafe)(dir);
+    const filePath = path.join(dir, `${name}.tsx`);
+    if ((0, fs_1.fileExists)(filePath)) {
         throw new Error(`Component "${name}" already exists at ${filePath}`);
     }
-    (0, utils_1.writeFileSafe)(filePath, renderComponent(name, type));
+    const directive = type === 'client' && ctx.profile.clientDirective;
+    (0, fs_1.writeFileSafe)(filePath, (0, component_1.renderComponent)(name, directive));
     console.log(`✅ Component "${name}" created at ${filePath}`);
 }

package/dist/commands/container.js

@@ -35,39 +35,18 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeContainer = makeContainer;
 const path = __importStar(require("path"));
-const utils_1 = require("../utils");
-function renderContainer(containerName, name, feature) {
-    const hookName = `use${name}`;
-    const hookPath = (0, utils_1.resolveImport)(feature, `hooks/${hookName}`);
-    const componentPath = (0, utils_1.resolveImport)(feature, `components/client/${name}`);
-    return `'use client';
-
-import { ${hookName} } from '${hookPath}';
-import ${name} from '${componentPath}';
-
-export default function ${containerName}() {
-  const { items, loading, error } = ${hookName}();
-
-  if (loading) return <div>Loading...</div>;
-  if (error) return <div>Error: {error}</div>;
-
-  return (
-    <div>
-      {items.map((item) => (
-        <${name} key={item.id} {...item} />
-      ))}
-    </div>
-  );
-}
-`;
-}
+const registry_1 = require("../stack/registry");
+const container_1 = require("../templates/frontend/container");
+const fs_1 = require("../utils/fs");
+const resolve_1 = require("./resolve");
 function makeContainer(feature, name, pascalName) {
-    const base = (0, utils_1.ensureFeatureExists)(feature, 'containers');
-    const filePath = path.join(base, `${name}.tsx`);
-    if ((0, utils_1.fileExists)(filePath)) {
+    const ctx = (0, resolve_1.requireFeature)(feature);
+    (0, registry_1.assertLayer)(ctx.profile, 'container', 'make:container');
+    const filePath = path.join((0, resolve_1.ensureLayerDir)(ctx, 'container'), `${name}.tsx`);
+    if ((0, fs_1.fileExists)(filePath)) {
         throw new Error(`Container "${name}" already exists at ${filePath}`);
     }
-    const entityName = pascalName ?? name.replace(/Container$/, '');
-    (0, utils_1.writeFileSafe)(filePath, renderContainer(name, entityName, feature));
+    const entity = pascalName ?? name.replace(/Container$/, '');
+    (0, fs_1.writeFileSafe)(filePath, (0, container_1.renderContainer)(ctx, name, entity, filePath));
     console.log(`✅ Container "${name}" created at ${filePath}`);
 }