@dawudesign/node-hexa-cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -73,19 +73,1062 @@ function checkLicense() {
   }
 }
 
-// src/index.ts
+// ../../packages/parser/dist/index.js
+import { Project } from "ts-morph";
+import fs from "fs";
+import path from "path";
+async function parseProject(rootPath) {
+  const tsConfigFilePath = path.resolve(rootPath, "tsconfig.json");
+  if (!fs.existsSync(tsConfigFilePath)) {
+    throw new Error(
+      `No tsconfig.json found at "${tsConfigFilePath}".
+Make sure you are pointing to a valid TypeScript project root.`
+    );
+  }
+  const project = new Project({ tsConfigFilePath });
+  const files = project.getSourceFiles().map((file) => {
+    const imports = file.getImportDeclarations().map((i) => i.getModuleSpecifierValue());
+    const classes = file.getClasses().map((cls) => ({
+      name: cls.getName() || "AnonymousClass",
+      decorators: cls.getDecorators().map((d) => d.getName())
+    }));
+    const interfaces = file.getInterfaces().map((i) => i.getName());
+    return {
+      path: file.getFilePath(),
+      imports,
+      classes,
+      interfaces
+    };
+  });
+  return { files };
+}
+
+// ../../packages/core/src/config.ts
+import path2 from "path";
+import fs2 from "fs";
+var defaultConfig = {
+  architecture: "hexagonal-ddd",
+  strict: true,
+  contextsDir: "src/contexts",
+  layers: {
+    domain: ["domain"],
+    application: ["application"],
+    infrastructure: ["infrastructure"],
+    adapterIn: ["controller", "http", "rest"],
+    adapterOut: ["repository", "persistence"]
+  }
+};
+function loadConfig(projectPath) {
+  const configPath = path2.join(projectPath, "node-hexa.config.json");
+  if (!fs2.existsSync(configPath)) {
+    return defaultConfig;
+  }
+  let userConfig;
+  try {
+    userConfig = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+  } catch {
+    throw new Error(`Failed to parse node-hexa.config.json at "${configPath}". Make sure it is valid JSON.`);
+  }
+  const userLayers = userConfig.layers && typeof userConfig.layers === "object" ? userConfig.layers : {};
+  return {
+    architecture: "hexagonal-ddd",
+    strict: typeof userConfig.strict === "boolean" ? userConfig.strict : defaultConfig.strict,
+    contextsDir: typeof userConfig.contextsDir === "string" && userConfig.contextsDir.length > 0 ? userConfig.contextsDir : defaultConfig.contextsDir,
+    layers: {
+      ...defaultConfig.layers,
+      ...userLayers
+    }
+  };
+}
+
+// ../../packages/rules/dist/index.js
+var SEVERITY_PENALTY = {
+  critical: 25,
+  high: 15,
+  medium: 10
+};
+function findNodeByImport(importPath, nodes) {
+  const normalizedImport = importPath.replaceAll("\\", "/").toLowerCase();
+  return nodes.find((n) => {
+    const filename = n.filePath.replaceAll("\\", "/").split("/").pop()?.replace(/\.ts$/, "").toLowerCase() ?? "";
+    return filename.length > 0 && normalizedImport.endsWith(filename);
+  });
+}
+function isOuterLayer(layer) {
+  return layer === "infrastructure" || layer === "adapter-in" || layer === "adapter-out";
+}
+function checkLayerViolation(node, target, violations) {
+  if (node.layer === "domain" && isOuterLayer(target.layer)) {
+    violations.push({
+      message: "Domain must not depend on infrastructure",
+      node: node.name,
+      filePath: node.filePath,
+      severity: "critical"
+    });
+    return;
+  }
+  if (node.layer === "domain" && target.layer === "application") {
+    violations.push({
+      message: "Domain must not depend on application",
+      node: node.name,
+      filePath: node.filePath,
+      severity: "critical"
+    });
+    return;
+  }
+  if (node.layer === "application" && isOuterLayer(target.layer)) {
+    violations.push({
+      message: "Application must not depend on infrastructure",
+      node: node.name,
+      filePath: node.filePath,
+      severity: "high"
+    });
+  }
+}
+function checkFrameworkViolations(node, violations) {
+  if (node.layer !== "domain") return;
+  const forbidden = ["@nestjs", "express", "prisma", "mongoose", "typeorm"];
+  for (const imp of node.imports) {
+    if (forbidden.some((f) => imp.includes(f))) {
+      violations.push({
+        message: "Domain must not depend on frameworks",
+        node: node.name,
+        filePath: node.filePath,
+        severity: "critical"
+      });
+      break;
+    }
+  }
+}
+function runRules(model, strict = true) {
+  const violations = [];
+  for (const node of model.nodes) {
+    for (const imp of node.imports) {
+      const target = findNodeByImport(imp, model.nodes);
+      if (target) {
+        checkLayerViolation(node, target, violations);
+      }
+    }
+    checkFrameworkViolations(node, violations);
+  }
+  return strict ? violations : violations.filter((v) => v.severity !== "medium");
+}
+function computeScore(violations) {
+  const penalty = violations.reduce(
+    (sum, v) => sum + SEVERITY_PENALTY[v.severity],
+    0
+  );
+  return {
+    score: Math.max(100 - penalty, 0),
+    max: 100
+  };
+}
+
+// ../../packages/core/src/index.ts
+import path11 from "path";
+
+// ../../packages/core/src/mermaid.ts
+function generateSubgraph(label, nodes) {
+  if (!nodes.length) return [];
+  return [`
+subgraph ${label}`, ...nodes.map((n) => `  ${n.name}`), "end"];
+}
+function importsTarget(imp, target) {
+  const fileBaseName = target.filePath.split("/").pop()?.replace(".ts", "") ?? "";
+  if (!fileBaseName) return false;
+  const normalizedImp = imp.replace(/\.ts$/, "");
+  return normalizedImp === fileBaseName || normalizedImp.endsWith(`/${fileBaseName}`);
+}
+function generateEdges(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const node of nodes) {
+    for (const imp of node.imports) {
+      for (const target of nodes) {
+        if (target === node) continue;
+        const edgeKey = `${node.name}-->${target.name}`;
+        if (!seen.has(edgeKey) && importsTarget(imp, target)) {
+          seen.add(edgeKey);
+          lines.push(`${node.name} --> ${target.name}`);
+        }
+      }
+    }
+  }
+  return lines;
+}
+function generateMermaidGraph(model) {
+  const { nodes } = model;
+  const byLayer = (layer) => nodes.filter((n) => n.layer === layer);
+  const subgraphs = [
+    ...generateSubgraph("Domain", byLayer("domain")),
+    ...generateSubgraph("Application", byLayer("application")),
+    ...generateSubgraph('AdapterIn["Adapter In (HTTP)"]', byLayer("adapter-in")),
+    ...generateSubgraph('AdapterOut["Adapter Out (Persistence)"]', byLayer("adapter-out")),
+    ...generateSubgraph("Infrastructure", byLayer("infrastructure"))
+  ];
+  return ["flowchart LR", ...subgraphs, ...generateEdges(nodes)].join("\n");
+}
+
+// ../../packages/core/src/docs.ts
+import fs3 from "fs";
+import path3 from "path";
+function generateDocs(result, projectPath) {
+  const graph = generateMermaidGraph(result.model);
+  const domain = result.model.nodes.filter((n) => n.layer === "domain");
+  const application = result.model.nodes.filter((n) => n.layer === "application");
+  const infrastructure = result.model.nodes.filter((n) => n.layer === "infrastructure");
+  let doc = "# Architecture Documentation\n\n";
+  doc += "## Architecture Diagram\n\n";
+  doc += "```mermaid\n";
+  doc += graph + "\n";
+  doc += "```\n\n";
+  doc += "## Domain\n";
+  domain.forEach((n) => {
+    doc += `- **${n.name}** (${n.kind}) \u2014 \`${n.filePath}\`
+`;
+  });
+  doc += "\n## Application\n";
+  application.forEach((n) => {
+    doc += `- **${n.name}** (${n.kind}) \u2014 \`${n.filePath}\`
+`;
+  });
+  doc += "\n## Infrastructure\n";
+  infrastructure.forEach((n) => {
+    doc += `- **${n.name}** (${n.kind}) \u2014 \`${n.filePath}\`
+`;
+  });
+  doc += "\n## Violations\n";
+  if (result.violations.length === 0) {
+    doc += "- \u2713 None\n";
+  } else {
+    result.violations.forEach((v) => {
+      doc += `- \u2717 **${v.message}** \u2014 \`${v.node}\` (${v.filePath})
+`;
+    });
+  }
+  doc += `
+## Architecture Score
+
+`;
+  doc += `**${result.score.score} / ${result.score.max}**
+`;
+  if (projectPath) {
+    const outputPath = path3.join(projectPath, "architecture.md");
+    fs3.writeFileSync(outputPath, doc);
+    console.log(`Architecture documentation generated: ${outputPath}`);
+  }
+  return doc;
+}
+
+// ../../packages/core/src/graph.ts
+import fs4 from "fs";
+import { execSync } from "child_process";
+import nodePath from "path";
+function getCandidateChromePaths() {
+  const candidates = [];
+  if (process.env.PUPPETEER_EXECUTABLE_PATH) {
+    candidates.push(process.env.PUPPETEER_EXECUTABLE_PATH);
+  }
+  candidates.push(
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"
+  );
+  const cwdChromeDir = nodePath.join(process.cwd(), "chrome");
+  if (fs4.existsSync(cwdChromeDir)) {
+    const entries = fs4.readdirSync(cwdChromeDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const localCandidate = nodePath.join(
+        cwdChromeDir,
+        entry.name,
+        "chrome-mac-arm64",
+        "Google Chrome for Testing.app",
+        "Contents",
+        "MacOS",
+        "Google Chrome for Testing"
+      );
+      candidates.push(localCandidate);
+    }
+  }
+  return candidates;
+}
+function resolveChromeExecutablePath() {
+  const candidates = getCandidateChromePaths();
+  for (const candidate of candidates) {
+    if (candidate && fs4.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function generateGraphFile(result) {
+  const graph = generateMermaidGraph(result.model);
+  const mermaidFile = "architecture.mmd";
+  const svgFile = "architecture.svg";
+  fs4.writeFileSync(mermaidFile, graph);
+  const chromeExecutablePath = resolveChromeExecutablePath();
+  execSync(
+    ["npx", "mmdc", "-i", mermaidFile, "-o", svgFile].join(" "),
+    {
+      env: {
+        ...process.env,
+        ...chromeExecutablePath ? { PUPPETEER_EXECUTABLE_PATH: chromeExecutablePath } : {}
+      },
+      stdio: "inherit"
+    }
+  );
+  return svgFile;
+}
+
+// ../../packages/core/src/context.ts
+import path4 from "path";
+function detectContexts(nodes) {
+  const contexts = {};
+  for (const node of nodes) {
+    const parts = path4.normalize(node.filePath).split(path4.sep);
+    const contextIndex = parts.findIndex(
+      (p) => ["domain", "application", "infrastructure"].includes(p)
+    );
+    if (contextIndex <= 0) continue;
+    const contextName = parts[contextIndex - 1];
+    if (!contexts[contextName]) {
+      contexts[contextName] = [];
+    }
+    contexts[contextName].push(node);
+  }
+  return contexts;
+}
+
+// ../../packages/core/src/init.ts
+import { execSync as execSync2 } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
+function detectPackageManager() {
+  try {
+    execSync2("pnpm --version", { stdio: "ignore" });
+    return "pnpm";
+  } catch {
+    return "npm";
+  }
+}
+function generateProject(name) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+    throw new Error(
+      `Invalid project name "${name}". Use lowercase letters, digits, and hyphens only (e.g. my-app).`
+    );
+  }
+  const dest = path5.join(process.cwd(), name);
+  if (fs5.existsSync(dest)) {
+    throw new Error(
+      `Directory "${name}" already exists. Remove it first or choose a different name.`
+    );
+  }
+  const pm = detectPackageManager();
+  console.log("Creating NestJS project...");
+  try {
+    execSync2(
+      `npx @nestjs/cli@latest new ${name} --package-manager ${pm} --skip-git`,
+      { stdio: "inherit" }
+    );
+  } catch {
+    throw new Error(
+      `Failed to scaffold the NestJS project "${name}".
+  Make sure you have a working internet connection and npm access.
+  Try manually: npx @nestjs/cli@latest new ${name}`
+    );
+  }
+  const base = path5.join(process.cwd(), name);
+  console.log("Applying Hexagonal DDD structure...");
+  const src = path5.join(base, "src");
+  fs5.rmSync(src, { recursive: true, force: true });
+  const dirs = [
+    "src/contexts/iam/domain/ports",
+    "src/contexts/iam/application/use-cases",
+    "src/contexts/iam/infrastructure/http",
+    "src/contexts/iam/infrastructure/persistence",
+    "src/shared"
+  ];
+  dirs.forEach((dir) => {
+    fs5.mkdirSync(path5.join(base, dir), { recursive: true });
+  });
+  fs5.writeFileSync(
+    path5.join(base, "src/main.ts"),
+    `import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+bootstrap();
+`
+  );
+  fs5.writeFileSync(
+    path5.join(base, "src/app.module.ts"),
+    `import { Module } from '@nestjs/common';
+import { IamModule } from './contexts/iam/iam.module';
+
+@Module({
+  imports: [IamModule],
+})
+export class AppModule {}
+`
+  );
+  fs5.writeFileSync(
+    path5.join(base, "src/contexts/iam/domain/entities/user.entity.ts"),
+    `export class User {
+  constructor(
+    public readonly id: string,
+    public readonly email: string,
+    public readonly name: string,
+  ) {}
+}
+`
+  );
+  fs5.writeFileSync(
+    path5.join(base, "src/contexts/iam/domain/ports/user.repository.port.ts"),
+    `import { User } from '../entities/user.entity';
+
+export const USER_REPOSITORY_PORT = Symbol('UserRepositoryPort');
+
+export interface UserRepositoryPort {
+  save(user: User): Promise<void>;
+  findById(id: string): Promise<User | null>;
+}
+`
+  );
+  fs5.writeFileSync(
+    path5.join(base, "src/contexts/iam/application/use-cases/create-user.usecase.ts"),
+    `import { Inject, Injectable } from '@nestjs/common';
+import { User } from '../../domain/entities/user.entity';
+import {
+  USER_REPOSITORY_PORT,
+  UserRepositoryPort,
+} from '../../domain/ports/user.repository.port';
+import { randomUUID } from 'node:crypto';
+
+export interface CreateUserDto {
+  email: string;
+  name: string;
+}
+
+@Injectable()
+export class CreateUserUseCase {
+  constructor(
+    @Inject(USER_REPOSITORY_PORT)
+    private readonly userRepository: UserRepositoryPort,
+  ) {}
+
+  async execute(dto: CreateUserDto): Promise<User> {
+    const user = new User(randomUUID(), dto.email, dto.name);
+    await this.userRepository.save(user);
+    return user;
+  }
+}
+`
+  );
+  fs5.writeFileSync(
+    path5.join(
+      base,
+      "src/contexts/iam/infrastructure/persistence/in-memory-user.repository.ts"
+    ),
+    `import { Injectable } from '@nestjs/common';
+import { User } from '../../domain/entities/user.entity';
+import { UserRepositoryPort } from '../../domain/ports/user.repository.port';
+
+@Injectable()
+export class InMemoryUserRepository implements UserRepositoryPort {
+  private readonly store = new Map<string, User>();
+
+  async save(user: User): Promise<void> {
+    this.store.set(user.id, user);
+  }
+
+  async findById(id: string): Promise<User | null> {
+    return this.store.get(id) ?? null;
+  }
+}
+`
+  );
+  fs5.writeFileSync(
+    path5.join(base, "src/contexts/iam/infrastructure/http/user.controller.ts"),
+    `import { Body, Controller, Post } from '@nestjs/common';
+import { CreateUserUseCase, CreateUserDto } from '../../application/use-cases/create-user.usecase';
+
+@Controller('users')
+export class UserController {
+  constructor(private readonly createUser: CreateUserUseCase) {}
+
+  @Post()
+  async create(@Body() dto: CreateUserDto) {
+    return this.createUser.execute(dto);
+  }
+}
+`
+  );
+  fs5.writeFileSync(
+    path5.join(base, "src/contexts/iam/iam.module.ts"),
+    `import { Module } from '@nestjs/common';
+import { USER_REPOSITORY_PORT } from './domain/ports/user.repository.port';
+import { InMemoryUserRepository } from './infrastructure/persistence/in-memory-user.repository';
+import { CreateUserUseCase } from './application/use-cases/create-user.usecase';
+import { UserController } from './infrastructure/http/user.controller';
+
+@Module({
+  controllers: [UserController],
+  providers: [
+    {
+      provide: USER_REPOSITORY_PORT,
+      useClass: InMemoryUserRepository,
+    },
+    CreateUserUseCase,
+  ],
+})
+export class IamModule {}
+`
+  );
+  fs5.writeFileSync(path5.join(base, "src/shared/.gitkeep"), "");
+  fs5.writeFileSync(
+    path5.join(base, "node-hexa.config.json"),
+    JSON.stringify(
+      {
+        architecture: "hexagonal-ddd",
+        strict: true,
+        contextsDir: "src/contexts"
+      },
+      null,
+      2
+    )
+  );
+  console.log(`
+\u2713 Hexagonal DDD NestJS project ready at ./${name}`);
+  console.log(`  cd ${name} && pnpm start:dev`);
+}
+
+// ../../packages/core/src/generate-context.ts
+import fs7 from "fs";
+import path7 from "path";
+
+// ../../packages/core/src/guards.ts
+import fs6 from "fs";
+import path6 from "path";
+var NAME_RE = /^[a-z][a-z0-9-]*$/;
+function assertKebabCase(value, label) {
+  if (!NAME_RE.test(value)) {
+    throw new Error(
+      `Invalid ${label} "${value}". Use lowercase letters, digits, and hyphens (e.g. my-context).`
+    );
+  }
+}
+function assertInsideProject() {
+  const pkgPath = path6.join(process.cwd(), "package.json");
+  if (!fs6.existsSync(pkgPath)) {
+    throw new Error(
+      "No package.json found. Run this command from the root of your NestJS project."
+    );
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
+  } catch {
+    throw new Error(
+      "Could not parse package.json. Make sure it contains valid JSON."
+    );
+  }
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (!allDeps["@nestjs/core"]) {
+    throw new Error(
+      "@nestjs/core not found in dependencies. node-hexa only works with NestJS projects."
+    );
+  }
+}
+
+// ../../packages/core/src/generate-context.ts
+function generateContext(name) {
+  assertKebabCase(name, "context name");
+  assertInsideProject();
+  const base = path7.join(process.cwd(), "src", "contexts", name);
+  if (fs7.existsSync(base)) {
+    throw new Error(
+      `Context '${name}' already exists at src/contexts/${name}.`
+    );
+  }
+  const dirs = [
+    "domain/entities",
+    "domain/value-objects",
+    "domain/ports",
+    "application/use-cases",
+    "infrastructure/http",
+    "infrastructure/persistence"
+  ];
+  dirs.forEach((dir) => {
+    fs7.mkdirSync(path7.join(base, dir), { recursive: true });
+  });
+  const pascal = capitalize(name);
+  const token = `${name.toUpperCase().replaceAll("-", "_")}_REPOSITORY_PORT`;
+  fs7.writeFileSync(
+    path7.join(base, "domain/entities", `${name}.entity.ts`),
+    `export class ${pascal} {
+  constructor(public readonly id: string) {}
+}
+`
+  );
+  fs7.writeFileSync(
+    path7.join(base, "domain/ports", `${name}.repository.port.ts`),
+    `import { ${pascal} } from '../entities/${name}.entity';
+
+export const ${token} = Symbol('${pascal}RepositoryPort');
+
+export interface ${pascal}RepositoryPort {
+  save(entity: ${pascal}): Promise<void>;
+  findById(id: string): Promise<${pascal} | null>;
+}
+`
+  );
+  fs7.writeFileSync(
+    path7.join(base, "application/use-cases", `create-${name}.usecase.ts`),
+    `import { Inject, Injectable } from '@nestjs/common';
+import { ${pascal} } from '../../domain/entities/${name}.entity';
+import {
+  ${token},
+  ${pascal}RepositoryPort,
+} from '../../domain/ports/${name}.repository.port';
+import { randomUUID } from 'node:crypto';
+
+@Injectable()
+export class Create${pascal}UseCase {
+  constructor(
+    @Inject(${token})
+    private readonly repository: ${pascal}RepositoryPort,
+  ) {}
+
+  async execute(id?: string): Promise<${pascal}> {
+    const entity = new ${pascal}(id ?? randomUUID());
+    await this.repository.save(entity);
+    return entity;
+  }
+}
+`
+  );
+  fs7.writeFileSync(
+    path7.join(base, "infrastructure/http", `${name}.controller.ts`),
+    `import { Controller, Post } from '@nestjs/common';
+import { Create${pascal}UseCase } from '../../application/use-cases/create-${name}.usecase';
+
+@Controller('${name}')
+export class ${pascal}Controller {
+  constructor(private readonly create${pascal}: Create${pascal}UseCase) {}
+
+  @Post()
+  async create() {
+    return this.create${pascal}.execute();
+  }
+}
+`
+  );
+  fs7.writeFileSync(
+    path7.join(
+      base,
+      "infrastructure/persistence",
+      `in-memory-${name}.repository.ts`
+    ),
+    `import { Injectable } from '@nestjs/common';
+import { ${pascal} } from '../../domain/entities/${name}.entity';
+import { ${pascal}RepositoryPort } from '../../domain/ports/${name}.repository.port';
+
+@Injectable()
+export class InMemory${pascal}Repository implements ${pascal}RepositoryPort {
+  private readonly store = new Map<string, ${pascal}>();
+
+  async save(entity: ${pascal}): Promise<void> {
+    this.store.set(entity.id, entity);
+  }
+
+  async findById(id: string): Promise<${pascal} | null> {
+    return this.store.get(id) ?? null;
+  }
+}
+`
+  );
+  fs7.writeFileSync(
+    path7.join(base, `${name}.module.ts`),
+    `import { Module } from '@nestjs/common';
+import { ${token} } from './domain/ports/${name}.repository.port';
+import { InMemory${pascal}Repository } from './infrastructure/persistence/in-memory-${name}.repository';
+import { Create${pascal}UseCase } from './application/use-cases/create-${name}.usecase';
+import { ${pascal}Controller } from './infrastructure/http/${name}.controller';
+
+@Module({
+  controllers: [${pascal}Controller],
+  providers: [
+    { provide: ${token}, useClass: InMemory${pascal}Repository },
+    Create${pascal}UseCase,
+  ],
+})
+export class ${pascal}Module {}
+`
+  );
+  console.log(`\u2713 Context '${name}' generated at src/contexts/${name}/`);
+  console.log(`  \u2192 Import ${pascal}Module in your AppModule to activate it.`);
+}
+function capitalize(str) {
+  return str.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+
+// ../../packages/core/src/generate-usecase.ts
+import fs8 from "fs";
+import path8 from "path";
+function findContextPort(base, context) {
+  const portsDir = path8.join(base, "domain/ports");
+  if (!fs8.existsSync(portsDir)) return null;
+  const portFile = fs8.readdirSync(portsDir).find((f) => f.endsWith(".repository.port.ts"));
+  if (!portFile) return null;
+  const baseName = portFile.replace(".repository.port.ts", "");
+  const pascal = capitalize2(baseName);
+  const token = `${baseName.toUpperCase().replaceAll("-", "_")}_REPOSITORY_PORT`;
+  return {
+    token,
+    interfaceName: `${pascal}RepositoryPort`,
+    importPath: `../../domain/ports/${baseName}.repository.port`,
+    paramName: `${context.replaceAll("-", "")}Repository`
+  };
+}
+function generateUseCase(name, context) {
+  assertKebabCase(name, "use case name");
+  assertKebabCase(context, "context name");
+  assertInsideProject();
+  const base = path8.join(process.cwd(), "src", "contexts", context);
+  if (!fs8.existsSync(base)) {
+    throw new Error(
+      `Context '${context}' does not exist at src/contexts/${context}. Run 'node-hexa generate context ${context}' first.`
+    );
+  }
+  const className = capitalize2(name) + "UseCase";
+  const usecasePath = path8.join(
+    base,
+    "application/use-cases",
+    `${name}.usecase.ts`
+  );
+  const dtoPath = path8.join(base, "application/use-cases", `${name}.dto.ts`);
+  const testPath = path8.join(
+    base,
+    "application/use-cases",
+    `${name}.usecase.spec.ts`
+  );
+  fs8.mkdirSync(path8.dirname(usecasePath), { recursive: true });
+  const port = findContextPort(base, context);
+  const usecaseContent = port ? `import { Inject, Injectable } from '@nestjs/common';
+import { ${port.token}, ${port.interfaceName} } from '${port.importPath}';
+import { ${className}Dto } from './${name}.dto';
+
+@Injectable()
+export class ${className} {
+  constructor(
+    @Inject(${port.token})
+    private readonly ${port.paramName}: ${port.interfaceName},
+  ) {}
+
+  async execute(dto: ${className}Dto): Promise<void> {
+    // TODO: implement use case logic
+  }
+}
+` : `import { Injectable } from '@nestjs/common';
+import { ${className}Dto } from './${name}.dto';
+
+@Injectable()
+export class ${className} {
+  async execute(dto: ${className}Dto): Promise<void> {
+    // TODO: inject a repository port via constructor and implement logic
+  }
+}
+`;
+  fs8.writeFileSync(usecasePath, usecaseContent);
+  fs8.writeFileSync(
+    dtoPath,
+    `export interface ${className}Dto {
+  id: string;
+}
+`
+  );
+  fs8.writeFileSync(
+    testPath,
+    `import { describe, it, expect } from 'vitest';
+import { ${className} } from './${name}.usecase';
+
+describe('${className}', () => {
+  it('should execute without errors', async () => {
+    const usecase = new ${className}(${port ? `{} as any` : ""});
+    await expect(usecase.execute({ id: '1' })).resolves.toBeUndefined();
+  });
+});
+`
+  );
+}
+function capitalize2(str) {
+  return str.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+
+// ../../packages/core/src/generate-aggregate.ts
+import fs9 from "fs";
+import path9 from "path";
+function generateAggregate(name, context) {
+  assertKebabCase(name, "aggregate name");
+  assertKebabCase(context, "context name");
+  assertInsideProject();
+  const base = path9.join(process.cwd(), "src", "contexts", context);
+  if (!fs9.existsSync(base)) {
+    throw new Error(
+      `Context '${context}' does not exist at src/contexts/${context}. Run 'node-hexa generate context ${context}' first.`
+    );
+  }
+  const pascal = capitalize3(name);
+  const token = `${name.toUpperCase().replaceAll("-", "_")}_REPOSITORY_PORT`;
+  const dirs = [
+    "domain/entities",
+    "domain/value-objects",
+    "domain/ports",
+    "application/use-cases",
+    "infrastructure/persistence",
+    "infrastructure/http"
+  ];
+  dirs.forEach((dir) => {
+    fs9.mkdirSync(path9.join(base, dir), { recursive: true });
+  });
+  fs9.writeFileSync(
+    path9.join(base, "domain/entities", `${name}.entity.ts`),
+    `export class ${pascal} {
+  constructor(public readonly id: string) {}
+}
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, "domain/value-objects", `${name}-id.vo.ts`),
+    `export class ${pascal}Id {
+  constructor(public readonly value: string) {}
+}
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, "domain/ports", `${name}.repository.port.ts`),
+    `import { ${pascal} } from '../entities/${name}.entity';
+
+export const ${token} = Symbol('${pascal}RepositoryPort');
+
+export interface ${pascal}RepositoryPort {
+  save(entity: ${pascal}): Promise<void>;
+  findById(id: string): Promise<${pascal} | null>;
+}
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, "application/use-cases", `create-${name}.dto.ts`),
+    `export type Create${pascal}Dto = {
+  id: string;
+};
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, "application/use-cases", `create-${name}.usecase.ts`),
+    `import { Inject, Injectable } from '@nestjs/common';
+import { ${pascal} } from '../../domain/entities/${name}.entity';
 import {
-  analyzeProject,
-  generateMermaidGraph,
-  generateDocs,
-  generateGraphFile,
-  detectContexts,
-  generateProject,
-  generateContext,
-  generateUseCase,
-  generateAggregate,
-  listContexts
-} from "@node-hexa/core";
+  ${token},
+  ${pascal}RepositoryPort,
+} from '../../domain/ports/${name}.repository.port';
+import { Create${pascal}Dto } from './create-${name}.dto';
+
+@Injectable()
+export class Create${pascal}UseCase {
+  constructor(
+    @Inject(${token})
+    private readonly repository: ${pascal}RepositoryPort,
+  ) {}
+
+  async execute(dto: Create${pascal}Dto): Promise<${pascal}> {
+    const entity = new ${pascal}(dto.id);
+    await this.repository.save(entity);
+    return entity;
+  }
+}
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, "application/use-cases", `create-${name}.usecase.spec.ts`),
+    `import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Create${pascal}UseCase } from './create-${name}.usecase';
+
+const mockRepository = {
+  save: vi.fn(),
+  findById: vi.fn(),
+};
+
+describe('Create${pascal}UseCase', () => {
+  let useCase: Create${pascal}UseCase;
+
+  beforeEach(() => {
+    useCase = new Create${pascal}UseCase(mockRepository as any);
+  });
+
+  it('should create and persist a ${pascal}', async () => {
+    const result = await useCase.execute({ id: '123' });
+    expect(result.id).toBe('123');
+    expect(mockRepository.save).toHaveBeenCalledWith(result);
+  });
+});
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, "infrastructure/persistence", `in-memory-${name}.repository.ts`),
+    `import { Injectable } from '@nestjs/common';
+import { ${pascal} } from '../../domain/entities/${name}.entity';
+import { ${pascal}RepositoryPort } from '../../domain/ports/${name}.repository.port';
+
+@Injectable()
+export class InMemory${pascal}Repository implements ${pascal}RepositoryPort {
+  private readonly store = new Map<string, ${pascal}>();
+
+  async save(entity: ${pascal}): Promise<void> {
+    this.store.set(entity.id, entity);
+  }
+
+  async findById(id: string): Promise<${pascal} | null> {
+    return this.store.get(id) ?? null;
+  }
+}
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, "infrastructure/http", `${name}.controller.ts`),
+    `import { Body, Controller, Post } from '@nestjs/common';
+import { Create${pascal}UseCase } from '../../application/use-cases/create-${name}.usecase';
+import { Create${pascal}Dto } from '../../application/use-cases/create-${name}.dto';
+
+@Controller('${name}')
+export class ${pascal}Controller {
+  constructor(private readonly create${pascal}: Create${pascal}UseCase) {}
+
+  @Post()
+  async create(@Body() dto: Create${pascal}Dto) {
+    return this.create${pascal}.execute(dto);
+  }
+}
+`
+  );
+  fs9.writeFileSync(
+    path9.join(base, `${name}.module.ts`),
+    `import { Module } from '@nestjs/common';
+import { ${token} } from './domain/ports/${name}.repository.port';
+import { InMemory${pascal}Repository } from './infrastructure/persistence/in-memory-${name}.repository';
+import { Create${pascal}UseCase } from './application/use-cases/create-${name}.usecase';
+import { ${pascal}Controller } from './infrastructure/http/${name}.controller';
+
+@Module({
+  controllers: [${pascal}Controller],
+  providers: [
+    { provide: ${token}, useClass: InMemory${pascal}Repository },
+    Create${pascal}UseCase,
+  ],
+})
+export class ${pascal}Module {}
+`
+  );
+  console.log(`\u2713 Aggregate '${name}' generated in context '${context}' at src/contexts/${context}/`);
+  console.log(`  \u2192 Import ${pascal}Module in your ${capitalize3(context)}Module or AppModule.`);
+}
+function capitalize3(str) {
+  return str.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+
+// ../../packages/core/src/list.ts
+import fs10 from "fs";
+import path10 from "path";
+function listFiles(dir) {
+  if (!fs10.existsSync(dir)) return [];
+  return fs10.readdirSync(dir).filter((f) => f.endsWith(".ts") && !f.endsWith(".spec.ts")).map((f) => f.replace(".ts", ""));
+}
+function listContexts(projectPath) {
+  const config = loadConfig(projectPath);
+  const contextsDir = path10.join(projectPath, config.contextsDir);
+  if (!fs10.existsSync(contextsDir)) return [];
+  return fs10.readdirSync(contextsDir).filter(
+    (entry) => fs10.statSync(path10.join(contextsDir, entry)).isDirectory()
+  ).map((ctxName) => {
+    const ctxPath = path10.join(contextsDir, ctxName);
+    return {
+      name: ctxName,
+      entities: listFiles(path10.join(ctxPath, "domain/entities")),
+      valueObjects: listFiles(path10.join(ctxPath, "domain/value-objects")),
+      ports: listFiles(path10.join(ctxPath, "domain/ports")),
+      useCases: listFiles(path10.join(ctxPath, "application/use-cases"))
+    };
+  });
+}
+
+// ../../packages/core/src/index.ts
+function detectLayer(filePath, config) {
+  const normalized = filePath.toLowerCase().replaceAll("\\", "/");
+  const dirPath = normalized.split("/").slice(0, -1).join("/");
+  if (config.layers.domain.some((l) => dirPath.includes(l)))
+    return "domain";
+  if (config.layers.application.some((l) => dirPath.includes(l)))
+    return "application";
+  if (config.layers.adapterIn?.some((l) => dirPath.includes(l)))
+    return "adapter-in";
+  if (config.layers.adapterOut?.some((l) => dirPath.includes(l)))
+    return "adapter-out";
+  if (config.layers.infrastructure.some((l) => dirPath.includes(l)))
+    return "infrastructure";
+  return "unknown";
+}
+function detectKind(name, decorators) {
+  if (decorators.includes("Controller")) return "controller";
+  if (decorators.includes("Injectable")) return "service";
+  if (decorators.includes("Module")) return "module";
+  if (name.endsWith("Controller")) return "controller";
+  if (name.endsWith("UseCase")) return "use-case";
+  if (name.endsWith("Repository")) return "repository";
+  if (name.endsWith("Entity")) return "entity";
+  if (name.endsWith("Service")) return "service";
+  if (name.endsWith("Port")) return "port";
+  if (name.endsWith("Adapter")) return "adapter";
+  if (name.endsWith("Vo") || name.endsWith("ValueObject") || name.endsWith("Id"))
+    return "value-object";
+  return "unknown";
+}
+async function analyzeProject(projectPath) {
+  const parsed = await parseProject(projectPath);
+  const config = loadConfig(projectPath);
+  const contextsAbsDir = path11.resolve(projectPath, config.contextsDir);
+  const nodes = parsed.files.filter((file) => {
+    const normalizedPath = path11.normalize(file.path);
+    return normalizedPath.startsWith(contextsAbsDir + path11.sep) || normalizedPath === contextsAbsDir;
+  }).flatMap((file) => [
+    ...file.classes.map((cls) => ({
+      name: cls.name,
+      filePath: file.path,
+      layer: detectLayer(file.path, config),
+      kind: detectKind(cls.name, cls.decorators),
+      imports: file.imports
+    })),
+    ...file.interfaces.map((itf) => ({
+      name: itf,
+      filePath: file.path,
+      layer: detectLayer(file.path, config),
+      kind: "port",
+      imports: file.imports
+    }))
+  ]);
+  const model = { nodes };
+  const violations = runRules(model, config.strict);
+  const score = computeScore(violations);
+  return {
+    model,
+    violations,
+    score
+  };
+}
+
+// src/index.ts
 function severityBadge(severity) {
   if (severity === "critical") return "CRITICAL";
   if (severity === "high") return "HIGH";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawudesign/node-hexa-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI to scaffold and analyze NestJS Hexagonal DDD projects",
   "keywords": [
     "nestjs",
@@ -19,7 +19,7 @@
     "dist"
   ],
   "bin": {
-    "node-hexa": "./dist/index.js"
+    "node-hexa": "dist/index.js"
   },
   "publishConfig": {
     "access": "public"
@@ -32,14 +32,15 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "@node-hexa/core": "workspace:^",
-    "@node-hexa/parser": "workspace:^",
-    "commander": "^14.0.3"
+    "commander": "^14.0.3",
+    "ts-morph": "^27.0.2"
   },
   "devDependencies": {
+    "@node-hexa/core": "workspace:^",
+    "@node-hexa/parser": "workspace:^",
     "@types/node": "^25.3.5",
     "tsup": "^8.0.0",
     "tsx": "^4.0.0",
     "typescript": "^5.3.0"
   }
-}
+}