@atlashub/smartstack-cli 3.43.0 → 3.44.0

package/dist/mcp-entry.mjs

@@ -25881,7 +25881,7 @@ var init_types3 = __esm({
     TenantModeSchema = external_exports.enum(["strict", "optional", "scoped", "none"]).default("strict");
     ValidateConventionsInputSchema = external_exports.object({
       path: external_exports.string().optional().describe("Project path to validate (default: SmartStack.app path)"),
-      checks: external_exports.array(external_exports.enum(["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "all"])).default(["all"]).describe("Types of checks to perform")
+      checks: external_exports.array(external_exports.enum(["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "code-patterns", "architecture", "all"])).default(["all"]).describe("Types of checks to perform")
     });
     CheckMigrationsInputSchema = external_exports.object({
       projectPath: external_exports.string().optional().describe("EF Core project path"),
@@ -26696,7 +26696,7 @@ import path8 from "path";
 async function handleValidateConventions(args, config2) {
   const input = ValidateConventionsInputSchema.parse(args);
   const projectPath = input.path || config2.smartstack.projectPath;
-  const checks = input.checks.includes("all") ? ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "code-patterns"] : input.checks;
+  const checks = input.checks.includes("all") ? ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "code-patterns", "architecture"] : input.checks;
   logger.info("Validating conventions", { projectPath, checks });
   const result = {
     valid: true,
@@ -26750,6 +26750,9 @@ async function handleValidateConventions(args, config2) {
   if (checks.includes("code-patterns")) {
     await validateCodePatterns(structure, config2, result);
   }
+  if (checks.includes("architecture")) {
+    await validateArchitecture(structure, config2, result);
+  }
   result.valid = result.errors.length === 0;
   result.summary = generateSummary(result, checks);
   return formatResult(result);
@@ -27185,13 +27188,13 @@ async function validateControllerRoutes(structure, _config, result) {
       if (navRouteMatch) {
         const routePath = navRouteMatch[1];
         const parts = routePath.split(".");
-        if (parts.length < 3) {
+        if (parts.length < 2) {
           result.errors.push({
             type: "error",
             category: "controllers",
             message: `Controller "${fileName}" has NavRoute with insufficient depth: "${routePath}"`,
             file: path8.relative(structure.root, file),
-            suggestion: 'NavRoute must have at least 3 levels: "application.module.section" (e.g., "administration.users.management")'
+            suggestion: 'NavRoute must have at least 2 levels: "application.module" (e.g., "administration.users")'
           });
         }
         const hasUppercase = parts.some((part) => part !== part.toLowerCase());
@@ -28102,6 +28105,132 @@ async function validateCodePatterns(structure, _config, result) {
     message: `Code patterns check completed: ${validatorFiles.length} validators, ${serviceFiles.length} services scanned`
   });
 }
+async function validateArchitecture(structure, _config, result) {
+  const layers = [
+    { path: structure.domain, name: "Domain", forbidden: [".Application", ".Infrastructure", ".Api"] },
+    { path: structure.application, name: "Application", forbidden: [".Infrastructure", ".Api"] }
+  ];
+  for (const layer of layers) {
+    if (!layer.path) continue;
+    const csFiles = await findFiles("**/*.cs", { cwd: layer.path });
+    for (const file of csFiles) {
+      const content = await readText(file);
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trimStart().startsWith("using ")) continue;
+        for (const forbidden of layer.forbidden) {
+          if (line.includes(forbidden)) {
+            result.errors.push({
+              type: "error",
+              category: "architecture",
+              message: `${layer.name} layer imports forbidden namespace: ${line.trim()}`,
+              file: path8.relative(structure.root, file),
+              line: i + 1,
+              suggestion: `${layer.name} must not depend on ${forbidden.replace(".", "")}. Move shared types to Domain or define interfaces in Application.`
+            });
+          }
+        }
+      }
+    }
+  }
+  if (structure.api) {
+    const controllerFiles = await findFiles("**/Controllers/**/*Controller.cs", { cwd: structure.api });
+    for (const file of controllerFiles) {
+      const content = await readText(file);
+      const dbContextFieldPattern = /private\s+readonly\s+\w*DbContext\b/;
+      const dbContextCtorPattern = /\w*DbContext\s+\w+[,)]/;
+      if (dbContextFieldPattern.test(content) || dbContextCtorPattern.test(content)) {
+        result.errors.push({
+          type: "error",
+          category: "architecture",
+          message: `Controller injects DbContext directly \u2014 violates Clean Architecture`,
+          file: path8.relative(structure.root, file),
+          suggestion: "Controllers must use Application services, not inject DbContext. Create an Application service with the required business logic."
+        });
+      }
+    }
+  }
+  if (structure.api && structure.domain) {
+    const domainFiles = await findFiles("**/Entities/**/*.cs", { cwd: structure.domain });
+    const entityNames = /* @__PURE__ */ new Set();
+    for (const file of domainFiles) {
+      const content = await readText(file);
+      const classMatch = content.match(/public\s+class\s+(\w+)\s*:/);
+      if (classMatch) {
+        const name = classMatch[1];
+        if (!name.endsWith("Dto") && !name.endsWith("Response") && !name.endsWith("ViewModel") && !name.endsWith("Command") && !name.endsWith("Query") && !name.startsWith("I")) {
+          entityNames.add(name);
+        }
+      }
+    }
+    if (entityNames.size > 0) {
+      const controllerFiles = await findFiles("**/Controllers/**/*Controller.cs", { cwd: structure.api });
+      for (const file of controllerFiles) {
+        const content = await readText(file);
+        for (const entityName of entityNames) {
+          const returnPattern = new RegExp(`ActionResult<${entityName}>|ActionResult<IEnumerable<${entityName}>>|ActionResult<List<${entityName}>>`, "g");
+          if (returnPattern.test(content)) {
+            result.warnings.push({
+              type: "warning",
+              category: "architecture",
+              message: `Controller returns Domain entity "${entityName}" instead of a DTO`,
+              file: path8.relative(structure.root, file),
+              suggestion: `Return ${entityName}ResponseDto instead of ${entityName}. API responses should never expose Domain entities directly.`
+            });
+          }
+        }
+      }
+    }
+  }
+  if (structure.application) {
+    const appServiceFiles = await findFiles("**/*Service.cs", { cwd: structure.application });
+    for (const file of appServiceFiles) {
+      const fileName = path8.basename(file, ".cs");
+      if (fileName.startsWith("I")) continue;
+      const content = await readText(file);
+      if (/public\s+class\s+\w+Service/.test(content)) {
+        result.warnings.push({
+          type: "warning",
+          category: "architecture",
+          message: `Service implementation "${fileName}" found in Application layer`,
+          file: path8.relative(structure.root, file),
+          suggestion: "Service implementations belong in Infrastructure. Application layer should only contain interfaces (I*Service)."
+        });
+      }
+    }
+  }
+  if (structure.domain) {
+    const domainServiceFiles = await findFiles("**/I*Service.cs", { cwd: structure.domain });
+    for (const file of domainServiceFiles) {
+      const content = await readText(file);
+      if (/public\s+interface\s+I\w+Service/.test(content)) {
+        result.warnings.push({
+          type: "warning",
+          category: "architecture",
+          message: `Service interface found in Domain layer: ${path8.basename(file)}`,
+          file: path8.relative(structure.root, file),
+          suggestion: "Service interfaces belong in Application layer, not Domain. Move to Application/Interfaces/."
+        });
+      }
+    }
+  }
+  if (structure.api) {
+    const apiServiceFiles = await findFiles("**/I*Service.cs", { cwd: structure.api });
+    for (const file of apiServiceFiles) {
+      const content = await readText(file);
+      if (/public\s+interface\s+I\w+Service/.test(content)) {
+        result.warnings.push({
+          type: "warning",
+          category: "architecture",
+          message: `Service interface found in Api layer: ${path8.basename(file)}`,
+          file: path8.relative(structure.root, file),
+          suggestion: "Service interfaces belong in Application layer, not Api. Move to Application/Interfaces/."
+        });
+      }
+    }
+  }
+}
 function generateSummary(result, checks) {
   const parts = [];
   parts.push(`Checks performed: ${checks.join(", ")}`);
@@ -28170,7 +28299,7 @@ var init_validate_conventions = __esm({
             type: "array",
             items: {
               type: "string",
-              enum: ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "code-patterns", "all"]
+              enum: ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "code-patterns", "architecture", "all"]
             },
             description: "Types of checks to perform",
             default: ["all"]
@@ -62642,26 +62771,76 @@ async function checkArchitecture(context) {
       }
       const isController = /Controller\.cs$/i.test(file.relativePath);
       if (isController) {
-        for (const { pattern, name: _name } of DIRECT_DB_PATTERNS) {
+        for (const { pattern, name: patternName } of DIRECT_DB_PATTERNS) {
           let match3;
           pattern.lastIndex = 0;
           while ((match3 = pattern.exec(file.content)) !== null) {
-            const hasComplexQuery = /\.Include\(/.test(file.content) && /\.ThenInclude\(/.test(file.content);
-            if (hasComplexQuery) {
-              const lineNumber = getLineNumber4(file.content, match3.index);
-              findings.push({
-                id: generateFindingId("architecture"),
-                category: "architecture",
-                severity: "warning",
-                title: "Complex Query in Controller",
-                description: "Controllers with complex queries (multiple Includes) should consider moving logic to a service.",
-                file: file.relativePath,
-                line: lineNumber,
-                suggestion: "Consider extracting complex query logic to an Application layer service.",
-                autoFixable: false
-              });
-              break;
-            }
+            const lineNumber = getLineNumber4(file.content, match3.index);
+            const lineContent = lines[lineNumber - 1]?.trim() || "";
+            findings.push({
+              id: generateFindingId("architecture"),
+              category: "architecture",
+              severity: "critical",
+              title: "Controller Injects DbContext Directly",
+              description: `${patternName} detected in controller. Controllers should use Application services, not inject DbContext directly. This violates Clean Architecture.`,
+              file: file.relativePath,
+              line: lineNumber,
+              code: truncateCode3(lineContent),
+              suggestion: "Create an Application service with the required business logic and inject it instead.",
+              autoFixable: false
+            });
+            break;
+          }
+        }
+      }
+      if (isController && fileLayer === "api") {
+        const returnTypePattern = /Task<ActionResult<(?!.*(?:Dto|Response|ViewModel|PaginatedResult))(\w+)>>/g;
+        let returnMatch;
+        while ((returnMatch = returnTypePattern.exec(file.content)) !== null) {
+          const entityName = returnMatch[1];
+          if (["string", "int", "bool", "Guid", "object", "IActionResult"].includes(entityName)) continue;
+          const lineNumber = getLineNumber4(file.content, returnMatch.index);
+          const lineContent = lines[lineNumber - 1]?.trim() || "";
+          findings.push({
+            id: generateFindingId("architecture"),
+            category: "architecture",
+            severity: "warning",
+            title: "API Returns Domain Entity",
+            description: `Controller returns "${entityName}" which may be a Domain entity. API endpoints should return DTOs, not Domain entities.`,
+            file: file.relativePath,
+            line: lineNumber,
+            code: truncateCode3(lineContent),
+            suggestion: `Return ${entityName}ResponseDto instead of ${entityName}. Create a DTO in the Application layer.`,
+            autoFixable: false
+          });
+        }
+      }
+      if (fileLayer === "domain") {
+        const efCorePatterns = [
+          { pattern: /\[Table\s*\(/g, name: "[Table] attribute" },
+          { pattern: /\[Column\s*\(/g, name: "[Column] attribute" },
+          { pattern: /\[Index\s*\(/g, name: "[Index] attribute" },
+          { pattern: /using\s+Microsoft\.EntityFrameworkCore/g, name: "EF Core using directive" }
+        ];
+        for (const { pattern: efPattern, name: efName } of efCorePatterns) {
+          let efMatch;
+          efPattern.lastIndex = 0;
+          while ((efMatch = efPattern.exec(file.content)) !== null) {
+            const lineNumber = getLineNumber4(file.content, efMatch.index);
+            const lineContent = lines[lineNumber - 1]?.trim() || "";
+            findings.push({
+              id: generateFindingId("architecture"),
+              category: "architecture",
+              severity: "critical",
+              title: "EF Core Concern in Domain Layer",
+              description: `${efName} found in Domain layer. Domain entities must be persistence-ignorant \u2014 EF Core configuration belongs in Infrastructure.`,
+              file: file.relativePath,
+              line: lineNumber,
+              code: truncateCode3(lineContent),
+              suggestion: "Move EF Core configuration to Infrastructure/Persistence/Configurations/ using IEntityTypeConfiguration<T>.",
+              autoFixable: false
+            });
+            break;
           }
         }
       }