@atlashub/smartstack-mcp 1.21.0 → 1.22.0

package/dist/index.js

@@ -2438,6 +2438,27 @@ Handlebars.registerHelper("camelCase", (str) => {
 Handlebars.registerHelper("kebabCase", (str) => {
   return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 });
+function resolveHierarchy(navRoute) {
+  if (!navRoute) {
+    return { context: "", application: "", module: "", domainPath: "", infraPath: "", controllerArea: "" };
+  }
+  const segments = navRoute.split(".");
+  const toPascal = (s) => s.split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+  const context = segments[0] ? toPascal(segments[0]) : "";
+  const application = segments[1] ? toPascal(segments[1]) : "";
+  const module = segments[2] ? toPascal(segments[2]) : segments[1] ? toPascal(segments[1]) : "";
+  let domainPath = "";
+  if (segments.length >= 3) {
+    domainPath = path8.join(context, application, module);
+  } else if (segments.length === 2) {
+    domainPath = path8.join(context, module);
+  } else if (segments.length === 1) {
+    domainPath = context;
+  }
+  const infraPath = module || "";
+  const controllerArea = context;
+  return { context, application, module, domainPath, infraPath, controllerArea };
+}
 async function handleScaffoldExtension(args, config) {
   const input = ScaffoldExtensionInputSchema.parse(args);
   const dryRun = input.options?.dryRun || false;
@@ -2582,17 +2603,21 @@ async function scaffoldFeature(name, options, structure, config, result, dryRun
   result.instructions.push(`${withRepository ? withValidation ? "5" : "4" : withValidation ? "4" : "3"}. Create migration: \`dotnet ef migrations add ${migrationPrefix}_vX.X.X_XXX_Add${name} --context ${dbContextName}\``);
   result.instructions.push(`${withRepository ? withValidation ? "6" : "5" : withValidation ? "5" : "4"}. Run migration: \`dotnet ef database update --context ${dbContextName}\``);
   if (!skipComponent) {
-    result.instructions.push(`Import component: \`import { ${name} } from './components/${name}';\``);
+    const featureHierarchy = resolveHierarchy(options?.navRoute);
+    const featureComponentPath = featureHierarchy.context && featureHierarchy.module ? `@/components/${featureHierarchy.context.toLowerCase()}/${featureHierarchy.module.toLowerCase()}/${name}` : `./components/${name}`;
+    result.instructions.push(`Import component: \`import { ${name} } from '${featureComponentPath}';\``);
   }
 }
 async function scaffoldService(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.application}.Services`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const interfaceNamespace = options?.namespace || `${config.conventions.namespaces.application}.Common.Interfaces`;
+  const implNamespace = hierarchy.infraPath ? `${config.conventions.namespaces.infrastructure}.Services.${hierarchy.infraPath}` : `${config.conventions.namespaces.infrastructure}.Services`;
   const methods = options?.methods || ["GetByIdAsync", "GetAllAsync", "CreateAsync", "UpdateAsync", "DeleteAsync"];
   const interfaceTemplate = `using System.Threading;
 using System.Threading.Tasks;
 using System.Collections.Generic;
 
-namespace {{namespace}};
+namespace {{interfaceNamespace}};
 
 /// <summary>
 /// Service interface for {{name}} operations
@@ -2613,7 +2638,7 @@ using System.Threading.Tasks;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 
-namespace {{namespace}};
+namespace {{implNamespace}};
 
 /// <summary>
 /// Service implementation for {{name}} operations
@@ -2643,19 +2668,22 @@ public class {{name}}Service : I{{name}}Service
   const diTemplate = `// Add to DependencyInjection.cs or ServiceCollectionExtensions.cs:
 services.AddScoped<I{{name}}Service, {{name}}Service>();
 `;
-  const context = { namespace, name, methods };
+  const context = { interfaceNamespace, implNamespace, name, methods };
   const interfaceContent = Handlebars.compile(interfaceTemplate)(context);
   const implementationContent = Handlebars.compile(implementationTemplate)(context);
   const diContent = Handlebars.compile(diTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
-  const basePath = structure.application || projectRoot;
-  const servicesPath = path8.join(basePath, "Services");
-  const interfacePath = path8.join(servicesPath, `I${name}Service.cs`);
-  const implementationPath = path8.join(servicesPath, `${name}Service.cs`);
+  const appPath = structure.application || projectRoot;
+  const infraPath = structure.infrastructure || path8.join(projectRoot, "Infrastructure");
+  const interfacesDir = path8.join(appPath, "Common", "Interfaces");
+  const implDir = hierarchy.infraPath ? path8.join(infraPath, "Services", hierarchy.infraPath) : path8.join(infraPath, "Services");
+  const interfacePath = path8.join(interfacesDir, `I${name}Service.cs`);
+  const implementationPath = path8.join(implDir, `${name}Service.cs`);
   validatePathSecurity(interfacePath, projectRoot);
   validatePathSecurity(implementationPath, projectRoot);
   if (!dryRun) {
-    await ensureDirectory(servicesPath);
+    await ensureDirectory(interfacesDir);
+    await ensureDirectory(implDir);
     await writeText(interfacePath, interfaceContent);
     await writeText(implementationPath, implementationContent);
   }
@@ -2665,7 +2693,8 @@ services.AddScoped<I{{name}}Service, {{name}}Service>();
   result.instructions.push(diContent);
 }
 async function scaffoldEntity(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || config.conventions.namespaces.domain;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.domainPath ? `${config.conventions.namespaces.domain}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}` : config.conventions.namespaces.domain);
   const baseEntity = options?.baseEntity;
   const isSystemEntity = options?.isSystemEntity || false;
   const tablePrefix = options?.tablePrefix || "ref_";
@@ -2895,15 +2924,17 @@ public class {{name}}Configuration : IEntityTypeConfiguration<{{name}}>
   const entityContent = Handlebars.compile(entityTemplate)(context);
   const configContent = Handlebars.compile(configTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
-  const domainPath = structure.domain || path8.join(projectRoot, "Domain");
-  const infraPath = structure.infrastructure || path8.join(projectRoot, "Infrastructure");
-  const entityFilePath = path8.join(domainPath, `${name}.cs`);
-  const configFilePath = path8.join(infraPath, "Persistence", "Configurations", `${name}Configuration.cs`);
+  const domainBase = structure.domain || path8.join(projectRoot, "Domain");
+  const infraBase = structure.infrastructure || path8.join(projectRoot, "Infrastructure");
+  const entityDir = hierarchy.domainPath ? path8.join(domainBase, hierarchy.domainPath) : domainBase;
+  const configDir = hierarchy.infraPath ? path8.join(infraBase, "Persistence", "Configurations", hierarchy.infraPath) : path8.join(infraBase, "Persistence", "Configurations");
+  const entityFilePath = path8.join(entityDir, `${name}.cs`);
+  const configFilePath = path8.join(configDir, `${name}Configuration.cs`);
   validatePathSecurity(entityFilePath, projectRoot);
   validatePathSecurity(configFilePath, projectRoot);
   if (!dryRun) {
-    await ensureDirectory(domainPath);
-    await ensureDirectory(path8.join(infraPath, "Persistence", "Configurations"));
+    await ensureDirectory(entityDir);
+    await ensureDirectory(configDir);
     await writeText(entityFilePath, entityContent);
     await writeText(configFilePath, configContent);
   }
@@ -3220,7 +3251,8 @@ GO
   result.instructions.push("- Group memberships (user belongs to parent groups)");
 }
 async function scaffoldController(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.api}.Controllers`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.controllerArea ? `${config.conventions.namespaces.api}.Controllers.${hierarchy.controllerArea}` : `${config.conventions.namespaces.api}.Controllers`);
   const navRoute = options?.navRoute;
   const navRouteSuffix = options?.navRouteSuffix;
   const routeAttribute = navRoute ? navRouteSuffix ? `[NavRoute("${navRoute}", Suffix = "${navRouteSuffix}")]` : `[NavRoute("${navRoute}")]` : `[Route("api/[controller]")]`;
@@ -3316,11 +3348,11 @@ public record Update{{name}}Request();
   const controllerContent = Handlebars.compile(controllerTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
   const apiPath = structure.api || path8.join(projectRoot, "Api");
-  const controllersPath = path8.join(apiPath, "Controllers");
-  const controllerFilePath = path8.join(controllersPath, `${name}Controller.cs`);
+  const controllersDir = hierarchy.controllerArea ? path8.join(apiPath, "Controllers", hierarchy.controllerArea) : path8.join(apiPath, "Controllers");
+  const controllerFilePath = path8.join(controllersDir, `${name}Controller.cs`);
   validatePathSecurity(controllerFilePath, projectRoot);
   if (!dryRun) {
-    await ensureDirectory(controllersPath);
+    await ensureDirectory(controllersDir);
     await writeText(controllerFilePath, controllerContent);
   }
   result.files.push({ path: controllerFilePath, content: controllerContent, type: "created" });
@@ -3346,6 +3378,7 @@ public record Update{{name}}Request();
   }
 }
 async function scaffoldComponent(name, options, structure, config, result, dryRun = false) {
+  const hierarchy = resolveHierarchy(options?.navRoute);
   const componentTemplate = `import React, { useState, useEffect } from 'react';
 
 interface {{name}}Props {
@@ -3498,7 +3531,8 @@ export function use{{name}}(options: Use{{name}}Options = {}) {
   const hookContent = Handlebars.compile(hookTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
   const webPath = structure.web || path8.join(projectRoot, "web");
-  const componentsPath = options?.outputPath || path8.join(webPath, "src", "components");
+  const componentsBase = path8.join(webPath, "src", "components");
+  const componentsPath = options?.outputPath ? options.outputPath : hierarchy.context && hierarchy.module ? path8.join(componentsBase, hierarchy.context.toLowerCase(), hierarchy.module.toLowerCase()) : componentsBase;
   const hooksPath = path8.join(webPath, "src", "hooks");
   const componentFilePath = path8.join(componentsPath, `${name}.tsx`);
   const hookFilePath = path8.join(hooksPath, `use${name}.ts`);
@@ -3513,8 +3547,9 @@ export function use{{name}}(options: Use{{name}}Options = {}) {
   result.files.push({ path: componentFilePath, content: componentContent, type: "created" });
   result.files.push({ path: hookFilePath, content: hookContent, type: "created" });
   result.instructions.push("Import and use the component:");
-  result.instructions.push(`import { ${name} } from './components/${name}';`);
-  result.instructions.push(`import { use${name} } from './hooks/use${name}';`);
+  const componentImportPath = hierarchy.context && hierarchy.module ? `@/components/${hierarchy.context.toLowerCase()}/${hierarchy.module.toLowerCase()}/${name}` : `./components/${name}`;
+  result.instructions.push(`import { ${name} } from '${componentImportPath}';`);
+  result.instructions.push(`import { use${name} } from '@/hooks/use${name}';`);
 }
 async function scaffoldTest(name, options, structure, config, result, dryRun = false) {
   const isSystemEntity = options?.isSystemEntity || false;
@@ -3642,7 +3677,8 @@ public class {{name}}ServiceTests
   result.instructions.push("- FluentAssertions");
 }
 async function scaffoldDtos(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.application}.DTOs`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.domainPath ? `${config.conventions.namespaces.application}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}.DTOs` : `${config.conventions.namespaces.application}.DTOs`);
   const isSystemEntity = options?.isSystemEntity || false;
   const properties = options?.entityProperties || [
     { name: "Name", type: "string", required: true, maxLength: 200 },
@@ -3759,7 +3795,7 @@ public record Update{{name}}Dto
   const createContent = Handlebars.compile(createDtoTemplate)(context);
   const updateContent = Handlebars.compile(updateDtoTemplate)(context);
   const basePath = structure.application || config.smartstack.projectPath;
-  const dtosPath = path8.join(basePath, "DTOs", name);
+  const dtosPath = hierarchy.domainPath ? path8.join(basePath, hierarchy.domainPath, "DTOs") : path8.join(basePath, "DTOs", name);
   const responseFilePath = path8.join(dtosPath, `${name}ResponseDto.cs`);
   const createFilePath = path8.join(dtosPath, `Create${name}Dto.cs`);
   const updateFilePath = path8.join(dtosPath, `Update${name}Dto.cs`);
@@ -3778,7 +3814,8 @@ public record Update{{name}}Dto
   result.instructions.push(`- Update${name}Dto: For PUT requests`);
 }
 async function scaffoldValidator(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.application}.Validators`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.domainPath ? `${config.conventions.namespaces.application}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}.Validators` : `${config.conventions.namespaces.application}.Validators`);
   const properties = options?.entityProperties || [
     { name: "Name", type: "string", required: true, maxLength: 200 },
     { name: "Description", type: "string?", required: false, maxLength: 500 }
@@ -3856,7 +3893,7 @@ public class Update{{name}}DtoValidator : AbstractValidator<Update{{name}}Dto>
   const createValidatorContent = Handlebars.compile(createValidatorTemplate)(context);
   const updateValidatorContent = Handlebars.compile(updateValidatorTemplate)(context);
   const basePath = structure.application || config.smartstack.projectPath;
-  const validatorsPath = path8.join(basePath, "Validators");
+  const validatorsPath = hierarchy.domainPath ? path8.join(basePath, hierarchy.domainPath, "Validators") : path8.join(basePath, "Validators");
   const createValidatorFilePath = path8.join(validatorsPath, `Create${name}DtoValidator.cs`);
   const updateValidatorFilePath = path8.join(validatorsPath, `Update${name}DtoValidator.cs`);
   if (!dryRun) {
@@ -3872,6 +3909,7 @@ public class Update{{name}}DtoValidator : AbstractValidator<Update{{name}}Dto>
   result.instructions.push("Required package: FluentValidation.DependencyInjectionExtensions");
 }
 async function scaffoldRepository(name, options, structure, config, result, dryRun = false) {
+  const hierarchy = resolveHierarchy(options?.navRoute);
   const isSystemEntity = options?.isSystemEntity || false;
   const schema = options?.schema || config.conventions.schemas.platform;
   const dbContextName = schema === "extensions" ? "ExtensionsDbContext" : "CoreDbContext";
@@ -3995,11 +4033,13 @@ public class {{name}}Repository : I{{name}}Repository
   const implementationContent = Handlebars.compile(implementationTemplate)(context);
   const appPath = structure.application || config.smartstack.projectPath;
   const infraPath = structure.infrastructure || path8.join(config.smartstack.projectPath, "Infrastructure");
-  const interfaceFilePath = path8.join(appPath, "Repositories", `I${name}Repository.cs`);
-  const implementationFilePath = path8.join(infraPath, "Repositories", `${name}Repository.cs`);
+  const appRepoDir = hierarchy.infraPath ? path8.join(appPath, "Repositories", hierarchy.infraPath) : path8.join(appPath, "Repositories");
+  const infraRepoDir = hierarchy.infraPath ? path8.join(infraPath, "Repositories", hierarchy.infraPath) : path8.join(infraPath, "Repositories");
+  const interfaceFilePath = path8.join(appRepoDir, `I${name}Repository.cs`);
+  const implementationFilePath = path8.join(infraRepoDir, `${name}Repository.cs`);
   if (!dryRun) {
-    await ensureDirectory(path8.join(appPath, "Repositories"));
-    await ensureDirectory(path8.join(infraPath, "Repositories"));
+    await ensureDirectory(appRepoDir);
+    await ensureDirectory(infraRepoDir);
     await writeText(interfaceFilePath, interfaceContent);
     await writeText(implementationFilePath, implementationContent);
   }