@atlashub/smartstack-mcp 1.6.0 → 1.8.0

package/dist/index.js

@@ -75,17 +75,17 @@ if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
 }
 
 // src/config.ts
-import path2 from "path";
+import path3 from "path";
 
 // src/utils/fs.ts
 import { stat, mkdir, readFile, writeFile, cp, rm } from "fs/promises";
 import path from "path";
 import { glob } from "glob";
 var FileSystemError = class extends Error {
-  constructor(message, operation, path21, cause) {
+  constructor(message, operation, path22, cause) {
     super(message);
     this.operation = operation;
-    this.path = path21;
+    this.path = path22;
     this.cause = cause;
     this.name = "FileSystemError";
   }
@@ -184,6 +184,125 @@ async function findFiles(pattern, options = {}) {
   return files;
 }
 
+// src/utils/dotnet.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import path2 from "path";
+var execAsync = promisify(exec);
+async function findCsprojFiles(cwd) {
+  return findFiles("**/*.csproj", { cwd: cwd || process.cwd() });
+}
+async function hasEfCore(csprojPath) {
+  try {
+    const content = await readText(csprojPath);
+    return content.includes("Microsoft.EntityFrameworkCore");
+  } catch {
+    return false;
+  }
+}
+async function findDbContextName(projectPath) {
+  try {
+    const csFiles = await findFiles("**/*.cs", { cwd: projectPath });
+    for (const file of csFiles) {
+      const content = await readText(file);
+      const match = content.match(/class\s+(\w+)\s*:\s*(?:\w+,\s*)*DbContext/);
+      if (match) {
+        return match[1];
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getTargetFramework(csprojPath) {
+  try {
+    const content = await readText(csprojPath);
+    const match = content.match(/<TargetFramework>([^<]+)<\/TargetFramework>/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function detectNamespaces(csprojFiles) {
+  if (csprojFiles.length === 0) {
+    return null;
+  }
+  const projectNames = csprojFiles.map((f) => path2.basename(f, ".csproj"));
+  const layerSuffixes = ["Domain", "Application", "Infrastructure", "Api", "Web", "Core", "Tests"];
+  const baseNamespaces = [];
+  for (const name of projectNames) {
+    const parts = name.split(".");
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const part = parts[i];
+      if (layerSuffixes.some((s) => s.toLowerCase() === part.toLowerCase())) {
+        const baseParts = parts.slice(0, i);
+        if (baseParts.length > 0) {
+          baseNamespaces.push(baseParts.join("."));
+        }
+        break;
+      }
+    }
+  }
+  if (baseNamespaces.length === 0) {
+    const commonPrefix = findCommonPrefix(projectNames);
+    if (commonPrefix && commonPrefix.length > 0) {
+      const base = commonPrefix.replace(/\.$/, "");
+      if (base) {
+        baseNamespaces.push(base);
+      }
+    }
+  }
+  if (baseNamespaces.length === 0) {
+    return null;
+  }
+  const baseNamespace = getMostCommon(baseNamespaces) || baseNamespaces[0];
+  return {
+    baseNamespace,
+    domain: `${baseNamespace}.Domain`,
+    application: `${baseNamespace}.Application`,
+    infrastructure: `${baseNamespace}.Infrastructure`,
+    api: `${baseNamespace}.Api`
+  };
+}
+function findCommonPrefix(strings) {
+  if (strings.length === 0) return "";
+  if (strings.length === 1) {
+    const parts = strings[0].split(".");
+    if (parts.length > 1) {
+      return parts.slice(0, -1).join(".") + ".";
+    }
+    return strings[0] + ".";
+  }
+  let prefix = strings[0];
+  for (let i = 1; i < strings.length; i++) {
+    while (strings[i].indexOf(prefix) !== 0 && prefix.length > 0) {
+      prefix = prefix.slice(0, -1);
+    }
+  }
+  const lastDot = prefix.lastIndexOf(".");
+  if (lastDot > 0 && !prefix.endsWith(".")) {
+    prefix = prefix.slice(0, lastDot + 1);
+  }
+  return prefix;
+}
+function getMostCommon(arr) {
+  if (arr.length === 0) return null;
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of arr) {
+    counts.set(item, (counts.get(item) || 0) + 1);
+  }
+  let maxCount = 0;
+  let mostCommon = arr[0];
+  for (const [item, count] of counts) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommon = item;
+    }
+  }
+  return mostCommon;
+}
+
 // src/config.ts
 var defaultConfig = {
   version: "1.0.0",
@@ -218,10 +337,12 @@ var defaultConfig = {
     },
     migrationFormat: "{context}_v{version}_{sequence}_{Description}",
     namespaces: {
-      domain: "SmartStack.Domain",
-      application: "SmartStack.Application",
-      infrastructure: "SmartStack.Infrastructure",
-      api: "SmartStack.Api"
+      // Empty = auto-detect from .csproj files
+      // Can be overridden in config file for custom namespaces
+      domain: "",
+      application: "",
+      infrastructure: "",
+      api: ""
     },
     servicePattern: {
       interface: "I{Name}Service",
@@ -268,7 +389,7 @@ async function getConfig() {
   if (cachedConfig) {
     return cachedConfig;
   }
-  const configPath = path2.join(process.cwd(), "config", "default-config.json");
+  const configPath = path3.join(process.cwd(), "config", "default-config.json");
   if (await fileExists(configPath)) {
     try {
       const fileConfig = await readJson(configPath);
@@ -285,6 +406,32 @@ async function getConfig() {
   cachedConfig.smartstack.projectPath = resolveProjectPath(
     cachedConfig.smartstack.projectPath
   );
+  const namespacesEmpty = !cachedConfig.conventions.namespaces.domain || !cachedConfig.conventions.namespaces.application || !cachedConfig.conventions.namespaces.infrastructure || !cachedConfig.conventions.namespaces.api;
+  if (namespacesEmpty && cachedConfig.smartstack.projectPath) {
+    try {
+      const csprojFiles = await findCsprojFiles(cachedConfig.smartstack.projectPath);
+      const detected = await detectNamespaces(csprojFiles);
+      if (detected) {
+        if (!cachedConfig.conventions.namespaces.domain) {
+          cachedConfig.conventions.namespaces.domain = detected.domain;
+        }
+        if (!cachedConfig.conventions.namespaces.application) {
+          cachedConfig.conventions.namespaces.application = detected.application;
+        }
+        if (!cachedConfig.conventions.namespaces.infrastructure) {
+          cachedConfig.conventions.namespaces.infrastructure = detected.infrastructure;
+        }
+        if (!cachedConfig.conventions.namespaces.api) {
+          cachedConfig.conventions.namespaces.api = detected.api;
+        }
+        logger.info("Namespaces auto-detected from project", { baseNamespace: detected.baseNamespace });
+      } else {
+        logger.warn("Could not auto-detect namespaces from .csproj files. Configure manually in config file.");
+      }
+    } catch (error) {
+      logger.warn("Failed to auto-detect namespaces", { error });
+    }
+  }
   if (process.env.SMARTSTACK_API_URL) {
     cachedConfig.smartstack.apiUrl = process.env.SMARTSTACK_API_URL;
   }
@@ -492,6 +639,7 @@ var SuggestTestScenariosInputSchema = z.object({
   depth: z.enum(["basic", "comprehensive", "security-focused"]).default("comprehensive").describe("Depth of analysis")
 });
 var ScaffoldApiClientInputSchema = z.object({
+  path: z.string().optional().describe("Path to SmartStack project root (defaults to configured project path)"),
   navRoute: z.string().min(1).describe('NavRoute path (e.g., "platform.administration.users")'),
   name: z.string().min(1).describe('Entity name in PascalCase (e.g., "User", "Order")'),
   methods: z.array(z.enum(["getAll", "getById", "create", "update", "delete", "search", "export"])).default(["getAll", "getById", "create", "update", "delete"]).describe("API methods to generate"),
@@ -503,6 +651,7 @@ var ScaffoldApiClientInputSchema = z.object({
   }).optional()
 });
 var ScaffoldRoutesInputSchema = z.object({
+  path: z.string().optional().describe("Path to SmartStack project root (defaults to configured project path)"),
   source: z.enum(["controllers", "navigation", "manual"]).default("controllers").describe("Source for route discovery: controllers (scan NavRoute attributes), navigation (from DB), manual (from config)"),
   scope: z.enum(["all", "platform", "business", "extensions"]).default("all").describe("Scope of routes to generate"),
   options: z.object({
@@ -514,6 +663,7 @@ var ScaffoldRoutesInputSchema = z.object({
   }).optional()
 });
 var ValidateFrontendRoutesInputSchema = z.object({
+  path: z.string().optional().describe("Path to SmartStack project root (defaults to configured project path)"),
   scope: z.enum(["api-clients", "routes", "registry", "all"]).default("all").describe("Scope of validation"),
   options: z.object({
     fix: z.boolean().default(false).describe("Auto-fix minor issues"),
@@ -522,13 +672,13 @@ var ValidateFrontendRoutesInputSchema = z.object({
 });
 
 // src/lib/detector.ts
-import path4 from "path";
+import path5 from "path";
 
 // src/utils/git.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-import path3 from "path";
-var execAsync = promisify(exec);
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import path4 from "path";
+var execAsync2 = promisify2(exec2);
 var GitError = class extends Error {
   constructor(message, command, cwd, cause) {
     super(message);
@@ -541,7 +691,7 @@ var GitError = class extends Error {
 async function git(command, cwd) {
   const options = cwd ? { cwd, maxBuffer: 10 * 1024 * 1024 } : { maxBuffer: 10 * 1024 * 1024 };
   try {
-    const { stdout } = await execAsync(`git ${command}`, options);
+    const { stdout } = await execAsync2(`git ${command}`, options);
     return stdout.trim();
   } catch (error) {
     const err = error instanceof Error ? error : new Error(String(error));
@@ -555,7 +705,7 @@ async function git(command, cwd) {
   }
 }
 async function isGitRepo(cwd) {
-  const gitDir = path3.join(cwd || process.cwd(), ".git");
+  const gitDir = path4.join(cwd || process.cwd(), ".git");
   return directoryExists(gitDir);
 }
 async function getCurrentBranch(cwd) {
@@ -589,51 +739,37 @@ async function getDiff(fromBranch, toBranch, filePath, cwd) {
   }
 }
 
-// src/utils/dotnet.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
-async function findCsprojFiles(cwd) {
-  return findFiles("**/*.csproj", { cwd: cwd || process.cwd() });
-}
-async function hasEfCore(csprojPath) {
-  try {
-    const content = await readText(csprojPath);
-    return content.includes("Microsoft.EntityFrameworkCore");
-  } catch {
-    return false;
+// src/lib/detector.ts
+import { glob as glob2 } from "glob";
+async function findWebProjectFolder(projectPath) {
+  const webSubfolders = await glob2("web/*/", { cwd: projectPath, absolute: true });
+  for (const folder of webSubfolders) {
+    const packageJsonPath = path5.join(folder, "package.json");
+    if (await fileExists(packageJsonPath)) {
+      return folder;
+    }
   }
-}
-async function findDbContextName(projectPath) {
-  try {
-    const csFiles = await findFiles("**/*.cs", { cwd: projectPath });
-    for (const file of csFiles) {
-      const content = await readText(file);
-      const match = content.match(/class\s+(\w+)\s*:\s*(?:\w+,\s*)*DbContext/);
-      if (match) {
-        return match[1];
-      }
+  const webDirect = path5.join(projectPath, "web");
+  if (await fileExists(path5.join(webDirect, "package.json"))) {
+    return webDirect;
+  }
+  const alternativeFolders = ["client", "frontend", "ui"];
+  for (const folderName of alternativeFolders) {
+    const altPath = path5.join(projectPath, folderName);
+    if (await fileExists(path5.join(altPath, "package.json"))) {
+      return altPath;
     }
-    return null;
-  } catch {
-    return null;
   }
-}
-async function getTargetFramework(csprojPath) {
-  try {
-    const content = await readText(csprojPath);
-    const match = content.match(/<TargetFramework>([^<]+)<\/TargetFramework>/);
-    return match ? match[1] : null;
-  } catch {
-    return null;
+  const srcWeb = path5.join(projectPath, "src", "web");
+  if (await fileExists(path5.join(srcWeb, "package.json"))) {
+    return srcWeb;
   }
+  return null;
 }
-
-// src/lib/detector.ts
 async function detectProject(projectPath) {
   logger.debug("Detecting project info", { path: projectPath });
   const info = {
-    name: path4.basename(projectPath),
+    name: path5.basename(projectPath),
     version: "0.0.0",
     isGitRepo: false,
     hasDotNet: false,
@@ -655,22 +791,25 @@ async function detectProject(projectPath) {
     for (const csproj of info.csprojFiles) {
       if (await hasEfCore(csproj)) {
         info.hasEfCore = true;
-        info.dbContextName = await findDbContextName(path4.dirname(csproj)) || void 0;
+        info.dbContextName = await findDbContextName(path5.dirname(csproj)) || void 0;
         break;
       }
     }
   }
-  const packageJsonPath = path4.join(projectPath, "web", "smartstack-web", "package.json");
-  if (await fileExists(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(await readText(packageJsonPath));
-      info.hasReact = !!packageJson.dependencies?.react;
-      info.version = packageJson.version || info.version;
-    } catch {
+  const webFolder = await findWebProjectFolder(projectPath);
+  if (webFolder) {
+    const packageJsonPath = path5.join(webFolder, "package.json");
+    if (await fileExists(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(await readText(packageJsonPath));
+        info.hasReact = !!packageJson.dependencies?.react;
+        info.version = packageJson.version || info.version;
+      } catch {
+      }
     }
   }
   if (info.csprojFiles.length > 0) {
-    const mainCsproj = info.csprojFiles.find((f) => f.includes("SmartStack.Api")) || info.csprojFiles[0];
+    const mainCsproj = info.csprojFiles.find((f) => /\.Api\.csproj$/i.test(f)) || info.csprojFiles.find((f) => /Api\.csproj$/i.test(f)) || info.csprojFiles[0];
     const targetFramework = await getTargetFramework(mainCsproj);
     if (targetFramework) {
       logger.debug("Target framework detected", { framework: targetFramework });
@@ -683,8 +822,8 @@ async function findSmartStackStructure(projectPath) {
   const structure = { root: projectPath };
   const csprojFiles = await findCsprojFiles(projectPath);
   for (const csproj of csprojFiles) {
-    const projectName = path4.basename(csproj, ".csproj").toLowerCase();
-    const projectDir = path4.dirname(csproj);
+    const projectName = path5.basename(csproj, ".csproj").toLowerCase();
+    const projectDir = path5.dirname(csproj);
     if (projectName.includes("domain")) {
       structure.domain = projectDir;
     } else if (projectName.includes("application")) {
@@ -696,14 +835,14 @@ async function findSmartStackStructure(projectPath) {
     }
   }
   if (structure.infrastructure) {
-    const migrationsPath = path4.join(structure.infrastructure, "Persistence", "Migrations");
+    const migrationsPath = path5.join(structure.infrastructure, "Persistence", "Migrations");
     if (await directoryExists(migrationsPath)) {
       structure.migrations = migrationsPath;
     }
   }
-  const webPath = path4.join(projectPath, "web", "smartstack-web");
-  if (await directoryExists(webPath)) {
-    structure.web = webPath;
+  const webFolder = await findWebProjectFolder(projectPath);
+  if (webFolder) {
+    structure.web = webFolder;
   }
   return structure;
 }
@@ -724,7 +863,7 @@ async function findControllerFiles(apiPath) {
 }
 
 // src/tools/validate-conventions.ts
-import path5 from "path";
+import path6 from "path";
 var validateConventionsTool = {
   name: "validate_conventions",
   description: "Validate AtlasHub/SmartStack conventions: SQL schemas (core/extensions), domain table prefixes (auth_, nav_, ai_, etc.), migration naming ({context}_v{version}_{sequence}_*), service interfaces (I*Service), namespace structure, controller routes (NavRoute)",
@@ -813,7 +952,7 @@ async function validateTablePrefixes(structure, config, result) {
           type: "error",
           category: "tables",
           message: `Table "${tableName}" uses invalid schema "${schemaName}"`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: `Use schema "${config.conventions.schemas.platform}" for SmartStack tables or "${config.conventions.schemas.extensions}" for client extensions`
         });
       }
@@ -823,7 +962,7 @@ async function validateTablePrefixes(structure, config, result) {
           type: "warning",
           category: "tables",
           message: `Table "${tableName}" does not use a standard domain prefix`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: `Consider using a domain prefix: ${validPrefixes.slice(0, 5).join(", ")}, etc.`
         });
       }
@@ -838,7 +977,7 @@ async function validateTablePrefixes(structure, config, result) {
           type: "error",
           category: "tables",
           message: `Table "${tableName}" uses unknown schema constant "${schemaConstant}"`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: `Use SchemaConstants.Core for SmartStack tables or SchemaConstants.Extensions for client extensions`
         });
       }
@@ -848,7 +987,7 @@ async function validateTablePrefixes(structure, config, result) {
           type: "warning",
           category: "tables",
           message: `Table "${tableName}" does not use a standard domain prefix`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: `Consider using a domain prefix: ${validPrefixes.slice(0, 5).join(", ")}, etc.`
         });
       }
@@ -861,7 +1000,7 @@ async function validateTablePrefixes(structure, config, result) {
           type: "error",
           category: "tables",
           message: `Table "${tableName}" is missing schema specification`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: `Add schema: .ToTable("${tableName}", SchemaConstants.Core)`
         });
       }
@@ -881,7 +1020,7 @@ async function validateMigrationNaming(structure, _config, result) {
   const migrationPattern = /^(\w+)_v(\d+\.\d+\.\d+)_(\d{3})_(.+)\.cs$/;
   const designerPattern = /\.Designer\.cs$/;
   for (const file of migrationFiles) {
-    const fileName = path5.basename(file);
+    const fileName = path6.basename(file);
     if (designerPattern.test(fileName) || fileName.includes("ModelSnapshot")) {
       continue;
     }
@@ -890,12 +1029,12 @@ async function validateMigrationNaming(structure, _config, result) {
         type: "error",
         category: "migrations",
         message: `Migration "${fileName}" does not follow naming convention`,
-        file: path5.relative(structure.root, file),
+        file: path6.relative(structure.root, file),
         suggestion: `Expected format: {context}_v{version}_{sequence}_{Description}.cs (e.g., core_v1.0.0_001_CreateAuthUsers.cs)`
       });
     }
   }
-  const orderedMigrations = migrationFiles.map((f) => path5.basename(f)).filter((f) => migrationPattern.test(f) && !f.includes("Designer")).sort();
+  const orderedMigrations = migrationFiles.map((f) => path6.basename(f)).filter((f) => migrationPattern.test(f) && !f.includes("Designer")).sort();
   for (let i = 1; i < orderedMigrations.length; i++) {
     const prev = orderedMigrations[i - 1];
     const curr = orderedMigrations[i];
@@ -928,7 +1067,7 @@ async function validateServiceInterfaces(structure, _config, result) {
   });
   for (const file of serviceFiles) {
     const content = await readText(file);
-    const fileName = path5.basename(file, ".cs");
+    const fileName = path6.basename(file, ".cs");
     if (fileName.startsWith("I")) continue;
     const expectedInterface = `I${fileName}`;
     const interfacePattern = new RegExp(`:\\s*${expectedInterface}\\b`);
@@ -939,7 +1078,7 @@ async function validateServiceInterfaces(structure, _config, result) {
           type: "warning",
           category: "services",
           message: `Service "${fileName}" should implement "${expectedInterface}"`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: `Create interface ${expectedInterface} and implement it`
         });
       }
@@ -966,7 +1105,7 @@ async function validateNamespaces(structure, config, result) {
             type: "error",
             category: "namespaces",
             message: `${layer.name} file has incorrect namespace "${namespace}"`,
-            file: path5.relative(structure.root, file),
+            file: path6.relative(structure.root, file),
             suggestion: `Should start with "${layer.expected}"`
           });
         }
@@ -986,7 +1125,7 @@ async function validateEntities(structure, _config, result) {
   const entityFiles = await findFiles("**/*.cs", { cwd: structure.domain });
   for (const file of entityFiles) {
     const content = await readText(file);
-    const fileName = path5.basename(file, ".cs");
+    const fileName = path6.basename(file, ".cs");
     if (fileName.endsWith("Dto") || fileName.endsWith("Command") || fileName.endsWith("Query") || fileName.endsWith("Handler") || fileName.endsWith("Validator") || fileName.endsWith("Exception") || fileName.startsWith("I")) {
       continue;
     }
@@ -1005,7 +1144,7 @@ async function validateEntities(structure, _config, result) {
         type: "warning",
         category: "entities",
         message: `Entity "${entityName}" inherits BaseEntity but doesn't implement ITenantEntity`,
-        file: path5.relative(structure.root, file),
+        file: path6.relative(structure.root, file),
         suggestion: "Add ITenantEntity interface for multi-tenant support, or use SystemEntity for platform-level entities"
       });
     }
@@ -1014,7 +1153,7 @@ async function validateEntities(structure, _config, result) {
         type: "warning",
         category: "entities",
         message: `Entity "${entityName}" is missing private constructor for EF Core`,
-        file: path5.relative(structure.root, file),
+        file: path6.relative(structure.root, file),
         suggestion: `Add: private ${entityName}() { }`
       });
     }
@@ -1023,7 +1162,7 @@ async function validateEntities(structure, _config, result) {
         type: "warning",
         category: "entities",
         message: `Entity "${entityName}" is missing factory method`,
-        file: path5.relative(structure.root, file),
+        file: path6.relative(structure.root, file),
         suggestion: `Add factory method: public static ${entityName} Create(...)`
       });
     }
@@ -1062,7 +1201,7 @@ async function validateTenantAwareness(structure, _config, result) {
           type: "error",
           category: "tenants",
           message: `Entity "${entityName}" implements ITenantEntity but is missing TenantId property`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: "Add: public Guid TenantId { get; private set; }"
         });
       }
@@ -1072,7 +1211,7 @@ async function validateTenantAwareness(structure, _config, result) {
           type: "error",
           category: "tenants",
           message: `Entity "${entityName}" implements ITenantEntity but Create() doesn't require tenantId`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: "Add tenantId as first parameter: Create(Guid tenantId, ...)"
         });
       }
@@ -1084,7 +1223,7 @@ async function validateTenantAwareness(structure, _config, result) {
           type: "error",
           category: "tenants",
           message: `System entity "${entityName}" should not have TenantId`,
-          file: path5.relative(structure.root, file),
+          file: path6.relative(structure.root, file),
           suggestion: "Remove TenantId from system entities"
         });
       }
@@ -1095,7 +1234,7 @@ async function validateTenantAwareness(structure, _config, result) {
         type: "warning",
         category: "tenants",
         message: `Entity "${entityName}" has TenantId but doesn't implement ITenantEntity`,
-        file: path5.relative(structure.root, file),
+        file: path6.relative(structure.root, file),
         suggestion: "Add ITenantEntity interface for explicit tenant-awareness"
       });
     }
@@ -1150,7 +1289,7 @@ async function validateControllerRoutes(structure, _config, result) {
   let systemControllerCount = 0;
   for (const file of controllerFiles) {
     const content = await readText(file);
-    const fileName = path5.basename(file, ".cs");
+    const fileName = path6.basename(file, ".cs");
     if (systemControllers.includes(fileName)) {
       systemControllerCount++;
       continue;
@@ -1168,7 +1307,7 @@ async function validateControllerRoutes(structure, _config, result) {
             type: "warning",
             category: "controllers",
             message: `Controller "${fileName}" has NavRoute with insufficient depth: "${routePath}"`,
-            file: path5.relative(structure.root, file),
+            file: path6.relative(structure.root, file),
             suggestion: 'NavRoute should have at least 2 levels: "context.application" (e.g., "platform.administration")'
           });
         }
@@ -1178,7 +1317,7 @@ async function validateControllerRoutes(structure, _config, result) {
             type: "error",
             category: "controllers",
             message: `Controller "${fileName}" has NavRoute with uppercase characters: "${routePath}"`,
-            file: path5.relative(structure.root, file),
+            file: path6.relative(structure.root, file),
             suggestion: 'NavRoute paths must be lowercase (e.g., "platform.administration.users")'
           });
         }
@@ -1189,7 +1328,7 @@ async function validateControllerRoutes(structure, _config, result) {
         type: "warning",
         category: "controllers",
         message: `Controller "${fileName}" uses hardcoded Route instead of NavRoute`,
-        file: path5.relative(structure.root, file),
+        file: path6.relative(structure.root, file),
         suggestion: 'Use [NavRoute("context.application.module")] for navigation-based routing'
       });
     }
@@ -1257,7 +1396,7 @@ function formatResult(result) {
 }
 
 // src/tools/check-migrations.ts
-import path6 from "path";
+import path7 from "path";
 var checkMigrationsTool = {
   name: "check_migrations",
   description: "Analyze EF Core migrations for conflicts, ordering issues, and ModelSnapshot discrepancies between branches",
@@ -1316,7 +1455,7 @@ async function parseMigrations(migrationsPath, rootPath) {
   const migrations = [];
   const pattern = /^(\w+)_v(\d+\.\d+\.\d+)_(\d{3})_(.+)\.cs$/;
   for (const file of files) {
-    const fileName = path6.basename(file);
+    const fileName = path7.basename(file);
     if (fileName.includes(".Designer.") || fileName.includes("ModelSnapshot")) {
       continue;
     }
@@ -1331,7 +1470,7 @@ async function parseMigrations(migrationsPath, rootPath) {
         sequence: match[3],
         // Sequence number (001, 002, etc.)
         description: match[4],
-        file: path6.relative(rootPath, file),
+        file: path7.relative(rootPath, file),
         applied: true
         // We'd need DB connection to check this
       });
@@ -1342,7 +1481,7 @@ async function parseMigrations(migrationsPath, rootPath) {
         version: "0.0.0",
         sequence: "000",
         description: fileName.replace(".cs", ""),
-        file: path6.relative(rootPath, file),
+        file: path7.relative(rootPath, file),
         applied: true
       });
     }
@@ -1432,10 +1571,10 @@ function checkChronologicalOrder(result) {
 }
 async function checkBranchConflicts(result, structure, currentBranch, compareBranch, projectPath) {
   if (!structure.migrations) return;
-  const migrationsRelPath = path6.relative(projectPath, structure.migrations).replace(/\\/g, "/");
+  const migrationsRelPath = path7.relative(projectPath, structure.migrations).replace(/\\/g, "/");
   const snapshotFiles = await findFiles("*ModelSnapshot.cs", { cwd: structure.migrations });
   if (snapshotFiles.length > 0) {
-    const snapshotRelPath = path6.relative(projectPath, snapshotFiles[0]).replace(/\\/g, "/");
+    const snapshotRelPath = path7.relative(projectPath, snapshotFiles[0]).replace(/\\/g, "/");
     const currentSnapshot = await readText(snapshotFiles[0]);
     const compareSnapshot = await getFileFromBranch(compareBranch, snapshotRelPath, projectPath);
     if (compareSnapshot && currentSnapshot !== compareSnapshot) {
@@ -1475,7 +1614,7 @@ async function checkModelSnapshot(result, structure) {
     result.conflicts.push({
       type: "snapshot",
       description: "Multiple ModelSnapshot files found",
-      files: snapshotFiles.map((f) => path6.relative(structure.root, f)),
+      files: snapshotFiles.map((f) => path7.relative(structure.root, f)),
       resolution: "Remove duplicate snapshots, keep only one per DbContext"
     });
   }
@@ -1562,7 +1701,7 @@ function formatResult2(result, currentBranch, compareBranch) {
 
 // src/tools/scaffold-extension.ts
 import Handlebars from "handlebars";
-import path7 from "path";
+import path8 from "path";
 var scaffoldExtensionTool = {
   name: "scaffold_extension",
   description: "Generate code to extend SmartStack: feature (full-stack), entity, service, controller, component, dto, validator, repository, or test",
@@ -1891,9 +2030,9 @@ services.AddScoped<I{{name}}Service, {{name}}Service>();
   const diContent = Handlebars.compile(diTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
   const basePath = structure.application || projectRoot;
-  const servicesPath = path7.join(basePath, "Services");
-  const interfacePath = path7.join(servicesPath, `I${name}Service.cs`);
-  const implementationPath = path7.join(servicesPath, `${name}Service.cs`);
+  const servicesPath = path8.join(basePath, "Services");
+  const interfacePath = path8.join(servicesPath, `I${name}Service.cs`);
+  const implementationPath = path8.join(servicesPath, `${name}Service.cs`);
   validatePathSecurity(interfacePath, projectRoot);
   validatePathSecurity(implementationPath, projectRoot);
   if (!dryRun) {
@@ -2137,15 +2276,15 @@ 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 || path7.join(projectRoot, "Domain");
-  const infraPath = structure.infrastructure || path7.join(projectRoot, "Infrastructure");
-  const entityFilePath = path7.join(domainPath, `${name}.cs`);
-  const configFilePath = path7.join(infraPath, "Persistence", "Configurations", `${name}Configuration.cs`);
+  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`);
   validatePathSecurity(entityFilePath, projectRoot);
   validatePathSecurity(configFilePath, projectRoot);
   if (!dryRun) {
     await ensureDirectory(domainPath);
-    await ensureDirectory(path7.join(infraPath, "Persistence", "Configurations"));
+    await ensureDirectory(path8.join(infraPath, "Persistence", "Configurations"));
     await writeText(entityFilePath, entityContent);
     await writeText(configFilePath, configContent);
   }
@@ -2259,9 +2398,9 @@ public record Update{{name}}Request();
   };
   const controllerContent = Handlebars.compile(controllerTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
-  const apiPath = structure.api || path7.join(projectRoot, "Api");
-  const controllersPath = path7.join(apiPath, "Controllers");
-  const controllerFilePath = path7.join(controllersPath, `${name}Controller.cs`);
+  const apiPath = structure.api || path8.join(projectRoot, "Api");
+  const controllersPath = path8.join(apiPath, "Controllers");
+  const controllerFilePath = path8.join(controllersPath, `${name}Controller.cs`);
   validatePathSecurity(controllerFilePath, projectRoot);
   if (!dryRun) {
     await ensureDirectory(controllersPath);
@@ -2441,11 +2580,11 @@ export function use{{name}}(options: Use{{name}}Options = {}) {
   const componentContent = Handlebars.compile(componentTemplate)(context);
   const hookContent = Handlebars.compile(hookTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
-  const webPath = structure.web || path7.join(projectRoot, "web", "smartstack-web");
-  const componentsPath = options?.outputPath || path7.join(webPath, "src", "components");
-  const hooksPath = path7.join(webPath, "src", "hooks");
-  const componentFilePath = path7.join(componentsPath, `${name}.tsx`);
-  const hookFilePath = path7.join(hooksPath, `use${name}.ts`);
+  const webPath = structure.web || path8.join(projectRoot, "web");
+  const componentsPath = options?.outputPath || path8.join(webPath, "src", "components");
+  const hooksPath = path8.join(webPath, "src", "hooks");
+  const componentFilePath = path8.join(componentsPath, `${name}.tsx`);
+  const hookFilePath = path8.join(hooksPath, `use${name}.ts`);
   validatePathSecurity(componentFilePath, projectRoot);
   validatePathSecurity(hookFilePath, projectRoot);
   if (!dryRun) {
@@ -2570,8 +2709,8 @@ public class {{name}}ServiceTests
     isSystemEntity
   };
   const testContent = Handlebars.compile(serviceTestTemplate2)(context);
-  const testsPath = structure.application ? path7.join(path7.dirname(structure.application), `${path7.basename(structure.application)}.Tests`, "Services") : path7.join(config.smartstack.projectPath, "Application.Tests", "Services");
-  const testFilePath = path7.join(testsPath, `${name}ServiceTests.cs`);
+  const testsPath = structure.application ? path8.join(path8.dirname(structure.application), `${path8.basename(structure.application)}.Tests`, "Services") : path8.join(config.smartstack.projectPath, "Application.Tests", "Services");
+  const testFilePath = path8.join(testsPath, `${name}ServiceTests.cs`);
   if (!dryRun) {
     await ensureDirectory(testsPath);
     await writeText(testFilePath, testContent);
@@ -2703,10 +2842,10 @@ 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 = path7.join(basePath, "DTOs", name);
-  const responseFilePath = path7.join(dtosPath, `${name}ResponseDto.cs`);
-  const createFilePath = path7.join(dtosPath, `Create${name}Dto.cs`);
-  const updateFilePath = path7.join(dtosPath, `Update${name}Dto.cs`);
+  const dtosPath = 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`);
   if (!dryRun) {
     await ensureDirectory(dtosPath);
     await writeText(responseFilePath, responseContent);
@@ -2800,9 +2939,9 @@ 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 = path7.join(basePath, "Validators");
-  const createValidatorFilePath = path7.join(validatorsPath, `Create${name}DtoValidator.cs`);
-  const updateValidatorFilePath = path7.join(validatorsPath, `Update${name}DtoValidator.cs`);
+  const validatorsPath = path8.join(basePath, "Validators");
+  const createValidatorFilePath = path8.join(validatorsPath, `Create${name}DtoValidator.cs`);
+  const updateValidatorFilePath = path8.join(validatorsPath, `Update${name}DtoValidator.cs`);
   if (!dryRun) {
     await ensureDirectory(validatorsPath);
     await writeText(createValidatorFilePath, createValidatorContent);
@@ -2935,12 +3074,12 @@ public class {{name}}Repository : I{{name}}Repository
   const interfaceContent = Handlebars.compile(interfaceTemplate)(context);
   const implementationContent = Handlebars.compile(implementationTemplate)(context);
   const appPath = structure.application || config.smartstack.projectPath;
-  const infraPath = structure.infrastructure || path7.join(config.smartstack.projectPath, "Infrastructure");
-  const interfaceFilePath = path7.join(appPath, "Repositories", `I${name}Repository.cs`);
-  const implementationFilePath = path7.join(infraPath, "Repositories", `${name}Repository.cs`);
+  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`);
   if (!dryRun) {
-    await ensureDirectory(path7.join(appPath, "Repositories"));
-    await ensureDirectory(path7.join(infraPath, "Repositories"));
+    await ensureDirectory(path8.join(appPath, "Repositories"));
+    await ensureDirectory(path8.join(infraPath, "Repositories"));
     await writeText(interfaceFilePath, interfaceContent);
     await writeText(implementationFilePath, implementationContent);
   }
@@ -2965,7 +3104,7 @@ function formatResult3(result, type, name, dryRun = false) {
     lines.push(dryRun ? "## \u{1F4C4} Files to Generate" : "## \u2705 Files Generated");
     lines.push("");
     for (const file of result.files) {
-      lines.push(`### ${file.type === "created" ? "\u{1F4C4}" : "\u270F\uFE0F"} ${path7.basename(file.path)}`);
+      lines.push(`### ${file.type === "created" ? "\u{1F4C4}" : "\u270F\uFE0F"} ${path8.basename(file.path)}`);
       lines.push(`**Path**: \`${file.path}\``);
       lines.push("");
       lines.push("```" + (file.path.endsWith(".cs") ? "csharp" : "typescript"));
@@ -3010,7 +3149,7 @@ function formatResult3(result, type, name, dryRun = false) {
 
 // src/tools/api-docs.ts
 import axios from "axios";
-import path8 from "path";
+import path9 from "path";
 var apiDocsTool = {
   name: "api_docs",
   description: "Get API documentation for SmartStack endpoints. Can fetch from Swagger/OpenAPI or parse controller files directly.",
@@ -3115,7 +3254,7 @@ async function parseControllers(structure) {
   const endpoints = [];
   for (const file of controllerFiles) {
     const content = await readText(file);
-    const fileName = path8.basename(file, ".cs");
+    const fileName = path9.basename(file, ".cs");
     const controllerName = fileName.replace("Controller", "");
     const routeMatch = content.match(/\[Route\s*\(\s*"([^"]+)"\s*\)\]/);
     const baseRoute = routeMatch ? routeMatch[1].replace("[controller]", controllerName.toLowerCase()) : `/api/${controllerName.toLowerCase()}`;
@@ -3375,7 +3514,7 @@ function formatAsOpenApi(endpoints) {
 
 // src/tools/suggest-migration.ts
 import { z as z2 } from "zod";
-import path9 from "path";
+import path10 from "path";
 var suggestMigrationTool = {
   name: "suggest_migration",
   description: "Suggest a migration name following SmartStack conventions ({context}_v{version}_{sequence}_{Description})",
@@ -3463,13 +3602,13 @@ async function handleSuggestMigration(args, config) {
 }
 async function findExistingMigrations(structure, config, context) {
   const migrations = [];
-  const infraPath = structure.infrastructure || path9.join(config.smartstack.projectPath, "Infrastructure");
-  const migrationsPath = path9.join(infraPath, "Migrations");
+  const infraPath = structure.infrastructure || path10.join(config.smartstack.projectPath, "Infrastructure");
+  const migrationsPath = path10.join(infraPath, "Migrations");
   try {
     const migrationFiles = await findFiles("*.cs", { cwd: migrationsPath });
     const migrationPattern = /^(\w+)_v(\d+\.\d+\.\d+)_(\d+)_(\w+)\.cs$/;
     for (const file of migrationFiles) {
-      const fileName = path9.basename(file);
+      const fileName = path10.basename(file);
       if (fileName.includes(".Designer.") || fileName.includes("ModelSnapshot")) {
         continue;
       }
@@ -3512,7 +3651,7 @@ function compareVersions2(a, b) {
 
 // src/tools/scaffold-tests.ts
 import Handlebars2 from "handlebars";
-import path10 from "path";
+import path11 from "path";
 var scaffoldTestsTool = {
   name: "scaffold_tests",
   description: "Generate unit, integration, and security tests for SmartStack entities, services, controllers, validators, and repositories. Ensures non-regression and maximum security coverage.",
@@ -4942,14 +5081,14 @@ async function scaffoldEntityTests(name, options, testTypes, structure, config,
   };
   if (testTypes.includes("unit")) {
     const content = Handlebars2.compile(entityTestTemplate)(context);
-    const testPath = path10.join(structure.root, "Tests", "Unit", "Domain", `${name}Tests.cs`);
+    const testPath = path11.join(structure.root, "Tests", "Unit", "Domain", `${name}Tests.cs`);
     validatePathSecurity(testPath, structure.root);
     if (!dryRun) {
-      await ensureDirectory(path10.dirname(testPath));
+      await ensureDirectory(path11.dirname(testPath));
       await writeText(testPath, content);
     }
     result.files.push({
-      path: path10.relative(structure.root, testPath),
+      path: path11.relative(structure.root, testPath),
       content,
       type: "created"
     });
@@ -4960,14 +5099,14 @@ async function scaffoldEntityTests(name, options, testTypes, structure, config,
       nameLower: name.charAt(0).toLowerCase() + name.slice(1),
       apiNamespace: config.conventions.namespaces.api
     });
-    const securityPath = path10.join(structure.root, "Tests", "Security", `${name}SecurityTests.cs`);
+    const securityPath = path11.join(structure.root, "Tests", "Security", `${name}SecurityTests.cs`);
     validatePathSecurity(securityPath, structure.root);
     if (!dryRun) {
-      await ensureDirectory(path10.dirname(securityPath));
+      await ensureDirectory(path11.dirname(securityPath));
       await writeText(securityPath, securityContent);
     }
     result.files.push({
-      path: path10.relative(structure.root, securityPath),
+      path: path11.relative(structure.root, securityPath),
       content: securityContent,
       type: "created"
     });
@@ -4988,14 +5127,14 @@ async function scaffoldServiceTests(name, options, testTypes, structure, config,
   };
   if (testTypes.includes("unit")) {
     const content = Handlebars2.compile(serviceTestTemplate)(context);
-    const testPath = path10.join(structure.root, "Tests", "Unit", "Services", `${name}ServiceTests.cs`);
+    const testPath = path11.join(structure.root, "Tests", "Unit", "Services", `${name}ServiceTests.cs`);
     validatePathSecurity(testPath, structure.root);
     if (!dryRun) {
-      await ensureDirectory(path10.dirname(testPath));
+      await ensureDirectory(path11.dirname(testPath));
       await writeText(testPath, content);
     }
     result.files.push({
-      path: path10.relative(structure.root, testPath),
+      path: path11.relative(structure.root, testPath),
       content,
       type: "created"
     });
@@ -5018,28 +5157,28 @@ async function scaffoldControllerTests(name, options, testTypes, structure, conf
   };
   if (testTypes.includes("integration")) {
     const content = Handlebars2.compile(controllerTestTemplate)(context);
-    const testPath = path10.join(structure.root, "Tests", "Integration", "Controllers", `${name}ControllerTests.cs`);
+    const testPath = path11.join(structure.root, "Tests", "Integration", "Controllers", `${name}ControllerTests.cs`);
     validatePathSecurity(testPath, structure.root);
     if (!dryRun) {
-      await ensureDirectory(path10.dirname(testPath));
+      await ensureDirectory(path11.dirname(testPath));
       await writeText(testPath, content);
     }
     result.files.push({
-      path: path10.relative(structure.root, testPath),
+      path: path11.relative(structure.root, testPath),
       content,
       type: "created"
     });
   }
   if (testTypes.includes("security")) {
     const securityContent = Handlebars2.compile(securityTestTemplate)(context);
-    const securityPath = path10.join(structure.root, "Tests", "Security", `${name}SecurityTests.cs`);
+    const securityPath = path11.join(structure.root, "Tests", "Security", `${name}SecurityTests.cs`);
     validatePathSecurity(securityPath, structure.root);
     if (!dryRun) {
-      await ensureDirectory(path10.dirname(securityPath));
+      await ensureDirectory(path11.dirname(securityPath));
       await writeText(securityPath, securityContent);
     }
     result.files.push({
-      path: path10.relative(structure.root, securityPath),
+      path: path11.relative(structure.root, securityPath),
       content: securityContent,
       type: "created"
     });
@@ -5057,14 +5196,14 @@ async function scaffoldValidatorTests(name, options, testTypes, structure, confi
   };
   if (testTypes.includes("unit")) {
     const content = Handlebars2.compile(validatorTestTemplate)(context);
-    const testPath = path10.join(structure.root, "Tests", "Unit", "Validators", `${name}ValidatorTests.cs`);
+    const testPath = path11.join(structure.root, "Tests", "Unit", "Validators", `${name}ValidatorTests.cs`);
     validatePathSecurity(testPath, structure.root);
     if (!dryRun) {
-      await ensureDirectory(path10.dirname(testPath));
+      await ensureDirectory(path11.dirname(testPath));
       await writeText(testPath, content);
     }
     result.files.push({
-      path: path10.relative(structure.root, testPath),
+      path: path11.relative(structure.root, testPath),
       content,
       type: "created"
     });
@@ -5084,14 +5223,14 @@ async function scaffoldRepositoryTests(name, options, testTypes, structure, conf
   };
   if (testTypes.includes("integration")) {
     const content = Handlebars2.compile(repositoryTestTemplate)(context);
-    const testPath = path10.join(structure.root, "Tests", "Integration", "Repositories", `${name}RepositoryTests.cs`);
+    const testPath = path11.join(structure.root, "Tests", "Integration", "Repositories", `${name}RepositoryTests.cs`);
     validatePathSecurity(testPath, structure.root);
     if (!dryRun) {
-      await ensureDirectory(path10.dirname(testPath));
+      await ensureDirectory(path11.dirname(testPath));
       await writeText(testPath, content);
     }
     result.files.push({
-      path: path10.relative(structure.root, testPath),
+      path: path11.relative(structure.root, testPath),
       content,
       type: "created"
     });
@@ -5141,7 +5280,7 @@ function formatTestResult(result, _target, name, dryRun) {
 }
 
 // src/tools/analyze-test-coverage.ts
-import path11 from "path";
+import path12 from "path";
 var analyzeTestCoverageTool = {
   name: "analyze_test_coverage",
   description: "Analyze test coverage for a SmartStack project. Identifies entities, services, and controllers without tests, calculates coverage ratios, and provides recommendations.",
@@ -5214,7 +5353,7 @@ async function analyzeEntityCoverage(structure, result) {
   }
   const entityFiles = await findFiles("**/*.cs", { cwd: structure.domain });
   const entityNames = extractComponentNames(entityFiles, ["Entity", "Aggregate"]);
-  const testPath = path11.join(structure.root, "Tests", "Unit", "Domain");
+  const testPath = path12.join(structure.root, "Tests", "Unit", "Domain");
   let testFiles = [];
   try {
     testFiles = await findFiles("**/*Tests.cs", { cwd: testPath });
@@ -5243,17 +5382,17 @@ async function analyzeServiceCoverage(structure, result) {
   }
   const serviceFiles = await findFiles("**/I*Service.cs", { cwd: structure.application });
   const serviceNames = serviceFiles.map((f) => {
-    const basename = path11.basename(f, ".cs");
+    const basename = path12.basename(f, ".cs");
     return basename.startsWith("I") ? basename.slice(1) : basename;
   }).filter((n) => n.endsWith("Service")).map((n) => n.replace(/Service$/, ""));
-  const testPath = path11.join(structure.root, "Tests", "Unit", "Services");
+  const testPath = path12.join(structure.root, "Tests", "Unit", "Services");
   let testFiles = [];
   try {
     testFiles = await findFiles("**/*ServiceTests.cs", { cwd: testPath });
   } catch {
   }
   const testedServices = testFiles.map((f) => {
-    const basename = path11.basename(f, ".cs");
+    const basename = path12.basename(f, ".cs");
     return basename.replace(/ServiceTests$/, "");
   });
   result.services.total = serviceNames.length;
@@ -5278,17 +5417,17 @@ async function analyzeControllerCoverage(structure, result) {
   }
   const controllerFiles = await findFiles("**/*Controller.cs", { cwd: structure.api });
   const controllerNames = controllerFiles.map((f) => {
-    const basename = path11.basename(f, ".cs");
+    const basename = path12.basename(f, ".cs");
     return basename.replace(/Controller$/, "");
   }).filter((n) => n !== "Base");
-  const testPath = path11.join(structure.root, "Tests", "Integration", "Controllers");
+  const testPath = path12.join(structure.root, "Tests", "Integration", "Controllers");
   let testFiles = [];
   try {
     testFiles = await findFiles("**/*ControllerTests.cs", { cwd: testPath });
   } catch {
   }
   const testedControllers = testFiles.map((f) => {
-    const basename = path11.basename(f, ".cs");
+    const basename = path12.basename(f, ".cs");
     return basename.replace(/ControllerTests$/, "");
   });
   result.controllers.total = controllerNames.length;
@@ -5307,7 +5446,7 @@ async function analyzeControllerCoverage(structure, result) {
   }
 }
 function extractComponentNames(files, excludeSuffixes = []) {
-  return files.map((f) => path11.basename(f, ".cs")).filter((name) => {
+  return files.map((f) => path12.basename(f, ".cs")).filter((name) => {
     const excludePatterns = [
       "Configuration",
       "Extensions",
@@ -5325,7 +5464,7 @@ function extractComponentNames(files, excludeSuffixes = []) {
 }
 function extractTestedNames(testFiles) {
   return testFiles.map((f) => {
-    const basename = path11.basename(f, ".cs");
+    const basename = path12.basename(f, ".cs");
     return basename.replace(/Tests$/, "");
   });
 }
@@ -5463,7 +5602,7 @@ function formatCoverageCell(category) {
 }
 
 // src/tools/validate-test-conventions.ts
-import path12 from "path";
+import path13 from "path";
 var validateTestConventionsTool = {
   name: "validate_test_conventions",
   description: "Validate that tests in a SmartStack project follow conventions: naming ({Method}_When{Condition}_Should{Result}), structure (Tests/Unit, Tests/Integration), patterns (AAA), assertions (FluentAssertions), and mocking (Moq).",
@@ -5526,7 +5665,7 @@ async function handleValidateTestConventions(args, config) {
     suggestions: [],
     autoFixedCount: 0
   };
-  const testsPath = path12.join(structure.root, "Tests");
+  const testsPath = path13.join(structure.root, "Tests");
   try {
     let testFiles = [];
     try {
@@ -5543,7 +5682,7 @@ async function handleValidateTestConventions(args, config) {
       await validateStructure(testsPath, testFiles, result);
     }
     for (const testFile of testFiles) {
-      const fullPath = path12.join(testsPath, testFile);
+      const fullPath = path13.join(testsPath, testFile);
       const content = await readText(fullPath);
       if (checks.includes("naming")) {
         validateNaming(testFile, content, result, input.autoFix);
@@ -5569,7 +5708,7 @@ async function validateStructure(testsPath, testFiles, result) {
   const expectedDirs = ["Unit", "Integration"];
   const foundDirs = /* @__PURE__ */ new Set();
   for (const file of testFiles) {
-    const parts = file.split(path12.sep);
+    const parts = file.split(path13.sep);
     if (parts.length > 1) {
       foundDirs.add(parts[0]);
     }
@@ -5586,8 +5725,8 @@ async function validateStructure(testsPath, testFiles, result) {
       });
     }
   }
-  const hasUnitDomain = testFiles.some((f) => f.includes(path12.join("Unit", "Domain")));
-  const hasIntegrationControllers = testFiles.some((f) => f.includes(path12.join("Integration", "Controllers")));
+  const hasUnitDomain = testFiles.some((f) => f.includes(path13.join("Unit", "Domain")));
+  const hasIntegrationControllers = testFiles.some((f) => f.includes(path13.join("Integration", "Controllers")));
   if (!hasUnitDomain && testFiles.some((f) => f.includes("Unit"))) {
     result.suggestions.push("Consider organizing unit tests into subdirectories: Unit/Domain, Unit/Services, Unit/Validators");
   }
@@ -5847,7 +5986,7 @@ function formatValidationResult(result) {
 }
 
 // src/tools/suggest-test-scenarios.ts
-import path13 from "path";
+import path14 from "path";
 var suggestTestScenariosTool = {
   name: "suggest_test_scenarios",
   description: "Analyze source code and suggest test scenarios based on detected methods, parameters, and patterns. Generates comprehensive test case recommendations for SmartStack components.",
@@ -5944,7 +6083,7 @@ async function findSourceFile(target, name, structure, _config) {
       pattern = `**/${name}Controller.cs`;
       break;
     case "file":
-      return path13.isAbsolute(name) ? name : path13.join(structure.root, name);
+      return path14.isAbsolute(name) ? name : path14.join(structure.root, name);
     default:
       return null;
   }
@@ -5953,11 +6092,11 @@ async function findSourceFile(target, name, structure, _config) {
     const altPattern = `**/*${name}*.cs`;
     const altFiles = await findFiles(altPattern, { cwd: searchPath });
     if (altFiles.length > 0) {
-      return path13.join(searchPath, altFiles[0]);
+      return path14.join(searchPath, altFiles[0]);
     }
     return null;
   }
-  return path13.join(searchPath, files[0]);
+  return path14.join(searchPath, files[0]);
 }
 function parseSourceCode(content) {
   const methods = [];
@@ -6351,7 +6490,7 @@ function getTypeEmoji(type) {
 }
 
 // src/tools/scaffold-api-client.ts
-import path14 from "path";
+import path15 from "path";
 var scaffoldApiClientTool = {
   name: "scaffold_api_client",
   description: `Generate TypeScript API client with NavRoute integration.
@@ -6370,6 +6509,10 @@ ensuring frontend routes stay synchronized with backend NavRoute attributes.`,
   inputSchema: {
     type: "object",
     properties: {
+      path: {
+        type: "string",
+        description: "Path to SmartStack project root (defaults to configured project path)"
+      },
       navRoute: {
         type: "string",
         description: 'NavRoute path (e.g., "platform.administration.users")'
@@ -6418,14 +6561,14 @@ async function scaffoldApiClient(input, config) {
   const includeHook = options?.includeHook ?? true;
   const nameLower = name.charAt(0).toLowerCase() + name.slice(1);
   const apiPath = navRouteToApiPath(navRoute);
-  const projectRoot = config.smartstack.projectPath;
+  const projectRoot = input.path || config.smartstack.projectPath;
   const structure = await findSmartStackStructure(projectRoot);
-  const webPath = structure.web || path14.join(projectRoot, "web", "smartstack-web");
-  const servicesPath = options?.outputPath || path14.join(webPath, "src", "services", "api");
-  const hooksPath = path14.join(webPath, "src", "hooks");
-  const typesPath = path14.join(webPath, "src", "types");
+  const webPath = structure.web || path15.join(projectRoot, "web");
+  const servicesPath = options?.outputPath || path15.join(webPath, "src", "services", "api");
+  const hooksPath = path15.join(webPath, "src", "hooks");
+  const typesPath = path15.join(webPath, "src", "types");
   const apiClientContent = generateApiClient(name, nameLower, navRoute, apiPath, methods);
-  const apiClientFile = path14.join(servicesPath, `${nameLower}.ts`);
+  const apiClientFile = path15.join(servicesPath, `${nameLower}.ts`);
   if (!dryRun) {
     await ensureDirectory(servicesPath);
     await writeText(apiClientFile, apiClientContent);
@@ -6433,7 +6576,7 @@ async function scaffoldApiClient(input, config) {
   result.files.push({ path: apiClientFile, content: apiClientContent, type: "created" });
   if (includeTypes) {
     const typesContent = generateTypes(name);
-    const typesFile = path14.join(typesPath, `${nameLower}.ts`);
+    const typesFile = path15.join(typesPath, `${nameLower}.ts`);
     if (!dryRun) {
       await ensureDirectory(typesPath);
       await writeText(typesFile, typesContent);
@@ -6442,7 +6585,7 @@ async function scaffoldApiClient(input, config) {
   }
   if (includeHook) {
     const hookContent = generateHook(name, nameLower, methods);
-    const hookFile = path14.join(hooksPath, `use${name}.ts`);
+    const hookFile = path15.join(hooksPath, `use${name}.ts`);
     if (!dryRun) {
       await ensureDirectory(hooksPath);
       await writeText(hookFile, hookContent);
@@ -6763,8 +6906,8 @@ function formatResult4(result, input) {
 }
 
 // src/tools/scaffold-routes.ts
-import path15 from "path";
-import { glob as glob2 } from "glob";
+import path16 from "path";
+import { glob as glob3 } from "glob";
 var scaffoldRoutesTool = {
   name: "scaffold_routes",
   description: `Generate React Router configuration from backend NavRoute attributes.
@@ -6782,6 +6925,10 @@ and generates corresponding frontend routing infrastructure.`,
   inputSchema: {
     type: "object",
     properties: {
+      path: {
+        type: "string",
+        description: "Path to SmartStack project root (defaults to configured project path)"
+      },
       source: {
         type: "string",
         enum: ["controllers", "navigation", "manual"],
@@ -6824,10 +6971,10 @@ async function scaffoldRoutes(input, config) {
   const includeLayouts = options?.includeLayouts ?? true;
   const includeGuards = options?.includeGuards ?? true;
   const generateRegistry = options?.generateRegistry ?? true;
-  const projectRoot = config.smartstack.projectPath;
+  const projectRoot = input.path || config.smartstack.projectPath;
   const structure = await findSmartStackStructure(projectRoot);
-  const webPath = structure.web || path15.join(projectRoot, "web", "smartstack-web");
-  const routesPath = options?.outputPath || path15.join(webPath, "src", "routes");
+  const webPath = structure.web || path16.join(projectRoot, "web");
+  const routesPath = options?.outputPath || path16.join(webPath, "src", "routes");
   const navRoutes = await discoverNavRoutes(structure, scope);
   if (navRoutes.length === 0) {
     result.success = false;
@@ -6836,7 +6983,7 @@ async function scaffoldRoutes(input, config) {
   }
   if (generateRegistry) {
     const registryContent = generateNavRouteRegistry(navRoutes);
-    const registryFile = path15.join(routesPath, "navRoutes.generated.ts");
+    const registryFile = path16.join(routesPath, "navRoutes.generated.ts");
     if (!dryRun) {
       await ensureDirectory(routesPath);
       await writeText(registryFile, registryContent);
@@ -6844,18 +6991,18 @@ async function scaffoldRoutes(input, config) {
     result.files.push({ path: registryFile, content: registryContent, type: "created" });
   }
   const routerContent = generateRouterConfig(navRoutes, includeGuards);
-  const routerFile = path15.join(routesPath, "index.tsx");
+  const routerFile = path16.join(routesPath, "index.tsx");
   if (!dryRun) {
     await ensureDirectory(routesPath);
     await writeText(routerFile, routerContent);
   }
   result.files.push({ path: routerFile, content: routerContent, type: "created" });
   if (includeLayouts) {
-    const layoutsPath = path15.join(webPath, "src", "layouts");
+    const layoutsPath = path16.join(webPath, "src", "layouts");
     const contexts = [...new Set(navRoutes.map((r) => r.navRoute.split(".")[0]))];
     for (const context of contexts) {
       const layoutContent = generateLayout(context);
-      const layoutFile = path15.join(layoutsPath, `${capitalize(context)}Layout.tsx`);
+      const layoutFile = path16.join(layoutsPath, `${capitalize(context)}Layout.tsx`);
       if (!dryRun) {
         await ensureDirectory(layoutsPath);
         await writeText(layoutFile, layoutContent);
@@ -6865,7 +7012,7 @@ async function scaffoldRoutes(input, config) {
   }
   if (includeGuards) {
     const guardsContent = generateRouteGuards();
-    const guardsFile = path15.join(routesPath, "guards.tsx");
+    const guardsFile = path16.join(routesPath, "guards.tsx");
     if (!dryRun) {
       await writeText(guardsFile, guardsContent);
     }
@@ -6883,7 +7030,7 @@ async function discoverNavRoutes(structure, scope) {
     logger.warn("No API project found");
     return routes;
   }
-  const controllerFiles = await glob2("**/*Controller.cs", {
+  const controllerFiles = await glob3("**/*Controller.cs", {
     cwd: apiPath,
     absolute: true,
     ignore: ["**/obj/**", "**/bin/**"]
@@ -6899,7 +7046,7 @@ async function discoverNavRoutes(structure, scope) {
         if (scope !== "all" && context !== scope) {
           continue;
         }
-        const controllerMatch = path15.basename(file).match(/(.+)Controller\.cs$/);
+        const controllerMatch = path16.basename(file).match(/(.+)Controller\.cs$/);
         const controllerName = controllerMatch ? controllerMatch[1] : "Unknown";
         const methods = [];
         if (content.includes("[HttpGet]")) methods.push("GET");
@@ -7244,8 +7391,8 @@ function formatResult5(result, input) {
 }
 
 // src/tools/validate-frontend-routes.ts
-import path16 from "path";
-import { glob as glob3 } from "glob";
+import path17 from "path";
+import { glob as glob4 } from "glob";
 var validateFrontendRoutesTool = {
   name: "validate_frontend_routes",
   description: `Validate frontend routes against backend NavRoute attributes.
@@ -7263,6 +7410,10 @@ Reports issues and provides actionable recommendations for synchronization.`,
   inputSchema: {
     type: "object",
     properties: {
+      path: {
+        type: "string",
+        description: "Path to SmartStack project root (defaults to configured project path)"
+      },
       scope: {
         type: "string",
         enum: ["api-clients", "routes", "registry", "all"],
@@ -7306,9 +7457,9 @@ async function validateFrontendRoutes(input, config) {
     recommendations: []
   };
   const { scope } = input;
-  const projectRoot = config.smartstack.projectPath;
+  const projectRoot = input.path || config.smartstack.projectPath;
   const structure = await findSmartStackStructure(projectRoot);
-  const webPath = structure.web || path16.join(projectRoot, "web", "smartstack-web");
+  const webPath = structure.web || path17.join(projectRoot, "web");
   const backendRoutes = await discoverBackendNavRoutes(structure);
   if (scope === "all" || scope === "registry") {
     await validateRegistry(webPath, backendRoutes, result);
@@ -7329,7 +7480,7 @@ async function discoverBackendNavRoutes(structure) {
   if (!apiPath) {
     return routes;
   }
-  const controllerFiles = await glob3("**/*Controller.cs", {
+  const controllerFiles = await glob4("**/*Controller.cs", {
     cwd: apiPath,
     absolute: true,
     ignore: ["**/obj/**", "**/bin/**"]
@@ -7342,7 +7493,7 @@ async function discoverBackendNavRoutes(structure) {
         const navRoute = navRouteMatch[1];
         const suffix = navRouteMatch[2];
         const fullNavRoute = suffix ? `${navRoute}.${suffix}` : navRoute;
-        const controllerMatch = path16.basename(file).match(/(.+)Controller\.cs$/);
+        const controllerMatch = path17.basename(file).match(/(.+)Controller\.cs$/);
         const controllerName = controllerMatch ? controllerMatch[1] : "Unknown";
         const methods = [];
         if (content.includes("[HttpGet]")) methods.push("GET");
@@ -7370,7 +7521,7 @@ async function discoverBackendNavRoutes(structure) {
   return routes;
 }
 async function validateRegistry(webPath, backendRoutes, result) {
-  const registryPath = path16.join(webPath, "src", "routes", "navRoutes.generated.ts");
+  const registryPath = path17.join(webPath, "src", "routes", "navRoutes.generated.ts");
   if (!await fileExists(registryPath)) {
     result.registry.exists = false;
     result.recommendations.push("Run `scaffold_routes` to generate navRoutes.generated.ts");
@@ -7400,8 +7551,8 @@ async function validateRegistry(webPath, backendRoutes, result) {
   }
 }
 async function validateApiClients(webPath, backendRoutes, result) {
-  const servicesPath = path16.join(webPath, "src", "services", "api");
-  const clientFiles = await glob3("**/*.ts", {
+  const servicesPath = path17.join(webPath, "src", "services", "api");
+  const clientFiles = await glob4("**/*.ts", {
     cwd: servicesPath,
     absolute: true,
     ignore: ["**/index.ts"]
@@ -7410,7 +7561,7 @@ async function validateApiClients(webPath, backendRoutes, result) {
   for (const file of clientFiles) {
     try {
       const content = await readText(file);
-      const relativePath = path16.relative(webPath, file);
+      const relativePath = path17.relative(webPath, file);
       const usesRegistry = content.includes("getRoute('") || content.includes('getRoute("');
       if (!usesRegistry) {
         const hardcodedMatch = content.match(/apiClient\.(get|post|put|delete)\s*[<(]\s*['"`]([^'"`]+)['"`]/);
@@ -7448,7 +7599,7 @@ async function validateApiClients(webPath, backendRoutes, result) {
   }
 }
 async function validateRoutes(webPath, backendRoutes, result) {
-  const routesPath = path16.join(webPath, "src", "routes", "index.tsx");
+  const routesPath = path17.join(webPath, "src", "routes", "index.tsx");
   if (!await fileExists(routesPath)) {
     result.routes.total = 0;
     result.routes.missing = backendRoutes.map((r) => r.navRoute);
@@ -8583,7 +8734,7 @@ Run specific or all checks:
 }
 
 // src/resources/project-info.ts
-import path17 from "path";
+import path18 from "path";
 var projectInfoResourceTemplate = {
   uri: "smartstack://project",
   name: "SmartStack Project Info",
@@ -8620,16 +8771,16 @@ async function getProjectInfoResource(config) {
   lines.push("```");
   lines.push(`${projectInfo.name}/`);
   if (structure.domain) {
-    lines.push(`\u251C\u2500\u2500 ${path17.basename(structure.domain)}/          # Domain layer (entities)`);
+    lines.push(`\u251C\u2500\u2500 ${path18.basename(structure.domain)}/          # Domain layer (entities)`);
   }
   if (structure.application) {
-    lines.push(`\u251C\u2500\u2500 ${path17.basename(structure.application)}/     # Application layer (services)`);
+    lines.push(`\u251C\u2500\u2500 ${path18.basename(structure.application)}/     # Application layer (services)`);
   }
   if (structure.infrastructure) {
-    lines.push(`\u251C\u2500\u2500 ${path17.basename(structure.infrastructure)}/  # Infrastructure (EF Core)`);
+    lines.push(`\u251C\u2500\u2500 ${path18.basename(structure.infrastructure)}/  # Infrastructure (EF Core)`);
   }
   if (structure.api) {
-    lines.push(`\u251C\u2500\u2500 ${path17.basename(structure.api)}/             # API layer (controllers)`);
+    lines.push(`\u251C\u2500\u2500 ${path18.basename(structure.api)}/             # API layer (controllers)`);
   }
   if (structure.web) {
     lines.push(`\u2514\u2500\u2500 web/smartstack-web/      # React frontend`);
@@ -8642,8 +8793,8 @@ async function getProjectInfoResource(config) {
     lines.push("| Project | Path |");
     lines.push("|---------|------|");
     for (const csproj of projectInfo.csprojFiles) {
-      const name = path17.basename(csproj, ".csproj");
-      const relativePath = path17.relative(projectPath, csproj);
+      const name = path18.basename(csproj, ".csproj");
+      const relativePath = path18.relative(projectPath, csproj);
       lines.push(`| ${name} | \`${relativePath}\` |`);
     }
     lines.push("");
@@ -8653,10 +8804,10 @@ async function getProjectInfoResource(config) {
       cwd: structure.migrations,
       ignore: ["*.Designer.cs"]
     });
-    const migrations = migrationFiles.map((f) => path17.basename(f)).filter((f) => !f.includes("ModelSnapshot") && !f.includes(".Designer.")).sort();
+    const migrations = migrationFiles.map((f) => path18.basename(f)).filter((f) => !f.includes("ModelSnapshot") && !f.includes(".Designer.")).sort();
     lines.push("## EF Core Migrations");
     lines.push("");
-    lines.push(`**Location**: \`${path17.relative(projectPath, structure.migrations)}\``);
+    lines.push(`**Location**: \`${path18.relative(projectPath, structure.migrations)}\``);
     lines.push(`**Total Migrations**: ${migrations.length}`);
     lines.push("");
     if (migrations.length > 0) {
@@ -8691,11 +8842,11 @@ async function getProjectInfoResource(config) {
   lines.push("dotnet build");
   lines.push("");
   lines.push("# Run API");
-  lines.push(`cd ${structure.api ? path17.relative(projectPath, structure.api) : "SmartStack.Api"}`);
+  lines.push(`cd ${structure.api ? path18.relative(projectPath, structure.api) : "src/Api"}`);
   lines.push("dotnet run");
   lines.push("");
   lines.push("# Run frontend");
-  lines.push(`cd ${structure.web ? path17.relative(projectPath, structure.web) : "web/smartstack-web"}`);
+  lines.push(`cd ${structure.web ? path18.relative(projectPath, structure.web) : "web"}`);
   lines.push("npm run dev");
   lines.push("");
   lines.push("# Create migration");
@@ -8718,7 +8869,7 @@ async function getProjectInfoResource(config) {
 }
 
 // src/resources/api-endpoints.ts
-import path18 from "path";
+import path19 from "path";
 var apiEndpointsResourceTemplate = {
   uri: "smartstack://api/",
   name: "SmartStack API Endpoints",
@@ -8743,7 +8894,7 @@ async function getApiEndpointsResource(config, endpointFilter) {
 }
 async function parseController(filePath, _rootPath) {
   const content = await readText(filePath);
-  const fileName = path18.basename(filePath, ".cs");
+  const fileName = path19.basename(filePath, ".cs");
   const controllerName = fileName.replace("Controller", "");
   const endpoints = [];
   const routeMatch = content.match(/\[Route\s*\(\s*"([^"]+)"\s*\)\]/);
@@ -8890,7 +9041,7 @@ function getMethodEmoji(method) {
 }
 
 // src/resources/db-schema.ts
-import path19 from "path";
+import path20 from "path";
 var dbSchemaResourceTemplate = {
   uri: "smartstack://schema/",
   name: "SmartStack Database Schema",
@@ -8980,7 +9131,7 @@ async function parseEntity(filePath, rootPath, _config) {
     tableName,
     properties,
     relationships,
-    file: path19.relative(rootPath, filePath)
+    file: path20.relative(rootPath, filePath)
   };
 }
 async function enrichFromConfigurations(entities, infrastructurePath, _config) {
@@ -9126,7 +9277,7 @@ function formatSchema(entities, filter, _config) {
 }
 
 // src/resources/entities.ts
-import path20 from "path";
+import path21 from "path";
 var entitiesResourceTemplate = {
   uri: "smartstack://entities/",
   name: "SmartStack Entities",
@@ -9186,7 +9337,7 @@ async function parseEntitySummary(filePath, rootPath, config) {
     hasSoftDelete,
     hasRowVersion,
     file: filePath,
-    relativePath: path20.relative(rootPath, filePath)
+    relativePath: path21.relative(rootPath, filePath)
   };
 }
 function inferTableInfo(entityName, config) {