@dawudesign/node-hexa-cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/license.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var SIGNING_SECRET = "2dc6d0a8b5c755f95a2e9fbca8c8e6c45226763dc2040ae5335bc86f480337bb";
+var CONFIG_DIR = join(homedir(), ".config", "node-hexa");
+var LICENSE_FILE = join(CONFIG_DIR, "license");
+function parseLicenseKey(key) {
+  const parts = key.split("-");
+  if (parts.length < 3 || parts[0] !== "NODEHEXA") return null;
+  const sig = parts.at(-1);
+  if (!sig) return null;
+  const encoded = parts.slice(1, -1).join("-");
+  let payload;
+  try {
+    payload = Buffer.from(encoded, "base64url").toString("utf8");
+  } catch {
+    return null;
+  }
+  const expectedSig = createHmac("sha256", SIGNING_SECRET).update(payload).digest("hex").slice(0, 16);
+  const sigOk = sig.length === expectedSig.length && timingSafeEqual(Buffer.from(sig), Buffer.from(expectedSig));
+  if (!sigOk) return null;
+  const colonIdx = payload.indexOf(":");
+  if (colonIdx === -1) return null;
+  return {
+    email: payload.slice(0, colonIdx),
+    expiresAt: payload.slice(colonIdx + 1)
+  };
+}
+function activateLicense(key) {
+  const parsed = parseLicenseKey(key.trim());
+  if (!parsed) {
+    console.error("\u2717 Invalid license key.");
+    process.exit(1);
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  if (parsed.expiresAt !== "lifetime" && parsed.expiresAt < today) {
+    console.error(`\u2717 This license key expired on ${parsed.expiresAt}.`);
+    process.exit(1);
+  }
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(LICENSE_FILE, key.trim(), "utf8");
+  console.log(`\u2713 License activated for ${parsed.email} (valid until: ${parsed.expiresAt})`);
+}
+function checkLicense() {
+  if (!existsSync(LICENSE_FILE)) {
+    console.error(
+      "\u2717 No license found. Purchase a license at https://your-website.com and run:\n  node-hexa activate <your-license-key>"
+    );
+    process.exit(1);
+  }
+  const key = readFileSync(LICENSE_FILE, "utf8").trim();
+  const parsed = parseLicenseKey(key);
+  if (!parsed) {
+    console.error(
+      "\u2717 License file is corrupted. Re-activate with:\n  node-hexa activate <your-license-key>"
+    );
+    process.exit(1);
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  if (parsed.expiresAt !== "lifetime" && parsed.expiresAt < today) {
+    console.error(
+      `\u2717 Your license expired on ${parsed.expiresAt}. Renew at https://your-website.com`
+    );
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+import {
+  analyzeProject,
+  generateMermaidGraph,
+  generateDocs,
+  generateGraphFile,
+  detectContexts,
+  generateProject,
+  generateContext,
+  generateUseCase,
+  generateAggregate,
+  listContexts
+} from "@node-hexa/core";
+function severityBadge(severity) {
+  if (severity === "critical") return "CRITICAL";
+  if (severity === "high") return "HIGH";
+  return "MEDIUM";
+}
+function printLayers(nodes) {
+  const layers = ["domain", "application", "infrastructure", "adapter-in", "adapter-out"];
+  for (const layer of layers) {
+    const layerNodes = nodes.filter((n) => n.layer === layer);
+    if (!layerNodes.length) continue;
+    console.log(layer.toUpperCase());
+    layerNodes.forEach((n) => console.log(`  \u2713 ${n.name} (${n.kind})`));
+    console.log("");
+  }
+}
+function printViolations(violations) {
+  console.log("Violations\n");
+  if (!violations.length) {
+    console.log("  \u2713 No architecture violations found\n");
+    return;
+  }
+  for (const v of violations) {
+    console.log(`  \u2717 [${severityBadge(v.severity)}] ${v.message} \u2192 ${v.node}`);
+  }
+}
+function printContexts(nodes) {
+  const contexts = detectContexts(nodes);
+  console.log("\nBounded Contexts\n");
+  for (const [name, ctxNodes] of Object.entries(contexts)) {
+    console.log(name.toUpperCase());
+    ctxNodes.forEach((n) => console.log(`  - ${n.name} (${n.kind})`));
+    console.log("");
+  }
+}
+function die(message, code = 1) {
+  console.error(`\u2717 ${message}`);
+  process.exit(code);
+}
+function handleError(err) {
+  die(err instanceof Error ? err.message : String(err), 1);
+}
+var program = new Command();
+program.name("node-hexa").description("Architecture analyzer and scaffolder for NestJS Hexagonal DDD").version(process.env["npm_package_version"] ?? "0.1.0");
+program.command("analyze").description("Analyze architecture layers, violations and bounded contexts").argument("<path>", "project path").action(async (projectPath) => {
+  try {
+    const result = await analyzeProject(projectPath);
+    console.log("\nArchitecture Graph (Mermaid)\n");
+    console.log(generateMermaidGraph(result.model));
+    printLayers(result.model.nodes);
+    printViolations(result.violations);
+    printContexts(result.model.nodes);
+    console.log("\nArchitecture Score\n");
+    console.log(`Score: ${result.score.score}/${result.score.max}
+`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("docs").description("Generate architecture.md with Mermaid diagram and violations").argument("<path>", "project path").action(async (projectPath) => {
+  try {
+    const result = await analyzeProject(projectPath);
+    generateDocs(result, projectPath);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("graph").description("Generate architecture.svg dependency graph").argument("<path>", "project path").action(async (projectPath) => {
+  try {
+    const result = await analyzeProject(projectPath);
+    const svgFile = generateGraphFile(result);
+    console.log(`Architecture graph generated: ${svgFile}`);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("init").description("Create a new NestJS Hexagonal DDD project").argument("<name>", "project name (lowercase, hyphens allowed)").action((name) => {
+  try {
+    generateProject(name);
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("generate").description("Generate a context, use case, or aggregate in an existing project").argument("<type>", "context | usecase | aggregate").argument("<name>", "resource name (kebab-case)").argument("[context]", "bounded context name (required for usecase and aggregate)").action((type, name, context) => {
+  try {
+    if (type === "context") {
+      generateContext(name);
+    } else if (type === "usecase") {
+      if (!context) die("Missing argument: <context> is required for generate usecase.\n  Usage: node-hexa generate usecase <name> <context>");
+      generateUseCase(name, context);
+      console.log(`\u2713 Use case '${name}' generated in context '${context}'`);
+    } else if (type === "aggregate") {
+      if (!context) die("Missing argument: <context> is required for generate aggregate.\n  Usage: node-hexa generate aggregate <name> <context>");
+      generateAggregate(name, context);
+    } else {
+      die(`Unknown type: '${type}'. Use context | usecase | aggregate`);
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("check").description("Check architecture rules \u2014 exits 1 on violations, 0 if clean").argument("<path>", "project path").option("-w, --watch", "re-run every 2s").action(async (projectPath, options) => {
+  const runCheck = async () => {
+    if (options.watch) process.stdout.write("\x1Bc");
+    const result = await analyzeProject(projectPath);
+    if (!result.violations.length) {
+      console.log("\u2713 Architecture check passed");
+      return true;
+    }
+    console.log("\u2717 Architecture violations detected\n");
+    result.violations.forEach(
+      (v) => console.log(`  [${severityBadge(v.severity)}] ${v.message} \u2192 ${v.node}`)
+    );
+    return false;
+  };
+  try {
+    const passed = await runCheck();
+    if (!options.watch) process.exit(passed ? 0 : 1);
+  } catch (err) {
+    console.error(`\u2717 ${err instanceof Error ? err.message : String(err)}`);
+    if (!options.watch) process.exit(2);
+  }
+  if (options.watch) {
+    console.log("\nWatching for changes\u2026 (Ctrl+C to stop)");
+    setInterval(async () => {
+      try {
+        await runCheck();
+      } catch (err) {
+        console.error(`\u2717 ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }, 2e3);
+  }
+});
+program.command("list").description("List all bounded contexts and their components").argument("<path>", "project path").action((projectPath) => {
+  try {
+    const contexts = listContexts(projectPath);
+    if (contexts.length === 0) {
+      console.log("No bounded contexts found. Expected: <path>/src/contexts/");
+      return;
+    }
+    console.log(`
+Bounded Contexts (${contexts.length})
+`);
+    for (const ctx of contexts) {
+      console.log(`  ${ctx.name.toUpperCase()}`);
+      if (ctx.entities.length) console.log(`    Entities      : ${ctx.entities.join(", ")}`);
+      if (ctx.valueObjects.length) console.log(`    Value Objects : ${ctx.valueObjects.join(", ")}`);
+      if (ctx.ports.length) console.log(`    Ports         : ${ctx.ports.join(", ")}`);
+      if (ctx.useCases.length) console.log(`    Use Cases     : ${ctx.useCases.join(", ")}`);
+      console.log("");
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+program.command("activate").description("Activate your node-hexa license").argument("<key>", "license key received after purchase").action((key) => {
+  activateLicense(key);
+});
+var noLicenseNeeded = ["activate", "--help", "-h", "--version", "-V", void 0];
+if (!noLicenseNeeded.includes(process.argv[2])) checkLicense();
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dawudesign/node-hexa-cli",
+  "version": "0.1.0",
+  "description": "CLI to scaffold and analyze NestJS Hexagonal DDD projects",
+  "keywords": [
+    "nestjs",
+    "hexagonal",
+    "ddd",
+    "architecture",
+    "cli",
+    "scaffold"
+  ],
+  "license": "UNLICENSED",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "node-hexa": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "echo 'Use: pnpm pub' && exit 1",
+    "pub": "pnpm build && chmod +x dist/index.js && npm publish --ignore-scripts",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@node-hexa/core": "workspace:^",
+    "@node-hexa/parser": "workspace:^",
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.3.0"
+  }
+}