@atlashub/smartstack-mcp 1.5.1 → 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, path18, cause) {
+  constructor(message, operation, path22, cause) {
     super(message);
     this.operation = operation;
-    this.path = path18;
+    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;
   }
@@ -491,15 +638,47 @@ var SuggestTestScenariosInputSchema = z.object({
   name: z.string().min(1).describe("Component name or file path"),
   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"),
+  options: z.object({
+    outputPath: z.string().optional().describe("Custom output path for generated files"),
+    includeTypes: z.boolean().default(true).describe("Generate TypeScript types"),
+    includeHook: z.boolean().default(true).describe("Generate React Query hook"),
+    dryRun: z.boolean().default(false).describe("Preview without writing files")
+  }).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({
+    outputPath: z.string().optional().describe("Custom output path"),
+    includeLayouts: z.boolean().default(true).describe("Generate layout components"),
+    includeGuards: z.boolean().default(true).describe("Include route guards for permissions"),
+    generateRegistry: z.boolean().default(true).describe("Generate navRoutes.generated.ts"),
+    dryRun: z.boolean().default(false).describe("Preview without writing files")
+  }).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"),
+    strict: z.boolean().default(false).describe("Fail on warnings")
+  }).optional()
+});
 
 // 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);
@@ -512,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));
@@ -526,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) {
@@ -560,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,
@@ -626,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 });
@@ -654,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")) {
@@ -667,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;
 }
@@ -695,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)",
@@ -784,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`
         });
       }
@@ -794,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.`
         });
       }
@@ -809,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`
         });
       }
@@ -819,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.`
         });
       }
@@ -832,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)`
         });
       }
@@ -852,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;
     }
@@ -861,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];
@@ -899,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`);
@@ -910,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`
         });
       }
@@ -937,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}"`
           });
         }
@@ -957,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;
     }
@@ -976,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"
       });
     }
@@ -985,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}() { }`
       });
     }
@@ -994,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(...)`
       });
     }
@@ -1033,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; }"
         });
       }
@@ -1043,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, ...)"
         });
       }
@@ -1055,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"
         });
       }
@@ -1066,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"
       });
     }
@@ -1121,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;
@@ -1139,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")'
           });
         }
@@ -1149,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")'
           });
         }
@@ -1160,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'
       });
     }
@@ -1228,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",
@@ -1287,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;
     }
@@ -1302,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
       });
@@ -1313,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
       });
     }
@@ -1403,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) {
@@ -1446,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"
     });
   }
@@ -1533,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",
@@ -1862,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) {
@@ -2108,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);
   }
@@ -2230,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);
@@ -2412,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) {
@@ -2541,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);
@@ -2674,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);
@@ -2771,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);
@@ -2906,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);
   }
@@ -2936,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"));
@@ -2981,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.",
@@ -3086,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()}`;
@@ -3346,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})",
@@ -3434,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;
       }
@@ -3483,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.",
@@ -4913,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"
     });
@@ -4931,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"
     });
@@ -4959,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"
     });
@@ -4989,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"
     });
@@ -5028,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"
     });
@@ -5055,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"
     });
@@ -5112,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.",
@@ -5185,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 });
@@ -5214,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;
@@ -5249,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;
@@ -5278,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",
@@ -5296,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$/, "");
   });
 }
@@ -5434,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).",
@@ -5497,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 {
@@ -5514,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);
@@ -5540,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]);
     }
@@ -5557,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");
   }
@@ -5818,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.",
@@ -5915,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;
   }
@@ -5924,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 = [];
@@ -6321,41 +6489,1300 @@ function getTypeEmoji(type) {
   }
 }
 
-// src/resources/conventions.ts
-var conventionsResourceTemplate = {
-  uri: "smartstack://conventions",
-  name: "AtlasHub Conventions",
-  description: "Documentation of AtlasHub/SmartStack naming conventions, patterns, and best practices",
-  mimeType: "text/markdown"
+// src/tools/scaffold-api-client.ts
+import path15 from "path";
+var scaffoldApiClientTool = {
+  name: "scaffold_api_client",
+  description: `Generate TypeScript API client with NavRoute integration.
+
+Creates:
+- Type-safe API service with CRUD methods
+- TypeScript interfaces for request/response
+- React Query hook (optional)
+- Integration with navRoutes.generated.ts registry
+
+Example:
+  scaffold_api_client navRoute="platform.administration.users" name="User"
+
+The generated client automatically resolves the API path from the NavRoute registry,
+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")'
+      },
+      name: {
+        type: "string",
+        description: 'Entity name in PascalCase (e.g., "User", "Order")'
+      },
+      methods: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: ["getAll", "getById", "create", "update", "delete", "search", "export"]
+        },
+        default: ["getAll", "getById", "create", "update", "delete"],
+        description: "API methods to generate"
+      },
+      options: {
+        type: "object",
+        properties: {
+          outputPath: { type: "string", description: "Custom output path" },
+          includeTypes: { type: "boolean", default: true, description: "Generate TypeScript types" },
+          includeHook: { type: "boolean", default: true, description: "Generate React Query hook" },
+          dryRun: { type: "boolean", default: false, description: "Preview without writing" }
+        }
+      }
+    },
+    required: ["navRoute", "name"]
+  }
 };
-async function getConventionsResource(config) {
-  const { schemas, tablePrefixes, codePrefixes, migrationFormat, namespaces, servicePattern } = config.conventions;
-  return `# AtlasHub SmartStack Conventions
+async function handleScaffoldApiClient(args, config) {
+  const input = ScaffoldApiClientInputSchema.parse(args);
+  logger.info("Scaffolding API client", { navRoute: input.navRoute, name: input.name });
+  const result = await scaffoldApiClient(input, config);
+  return formatResult4(result, input);
+}
+async function scaffoldApiClient(input, config) {
+  const result = {
+    success: true,
+    files: [],
+    instructions: []
+  };
+  const { navRoute, name, methods, options } = input;
+  const dryRun = options?.dryRun ?? false;
+  const includeTypes = options?.includeTypes ?? true;
+  const includeHook = options?.includeHook ?? true;
+  const nameLower = name.charAt(0).toLowerCase() + name.slice(1);
+  const apiPath = navRouteToApiPath(navRoute);
+  const projectRoot = input.path || config.smartstack.projectPath;
+  const structure = await findSmartStackStructure(projectRoot);
+  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 = path15.join(servicesPath, `${nameLower}.ts`);
+  if (!dryRun) {
+    await ensureDirectory(servicesPath);
+    await writeText(apiClientFile, apiClientContent);
+  }
+  result.files.push({ path: apiClientFile, content: apiClientContent, type: "created" });
+  if (includeTypes) {
+    const typesContent = generateTypes(name);
+    const typesFile = path15.join(typesPath, `${nameLower}.ts`);
+    if (!dryRun) {
+      await ensureDirectory(typesPath);
+      await writeText(typesFile, typesContent);
+    }
+    result.files.push({ path: typesFile, content: typesContent, type: "created" });
+  }
+  if (includeHook) {
+    const hookContent = generateHook(name, nameLower, methods);
+    const hookFile = path15.join(hooksPath, `use${name}.ts`);
+    if (!dryRun) {
+      await ensureDirectory(hooksPath);
+      await writeText(hookFile, hookContent);
+    }
+    result.files.push({ path: hookFile, content: hookContent, type: "created" });
+  }
+  result.instructions.push(`Import the API client: import { ${nameLower}Api } from './services/api/${nameLower}';`);
+  if (includeHook) {
+    result.instructions.push(`Import the hook: import { use${name}, use${name}List } from './hooks/use${name}';`);
+  }
+  result.instructions.push(`Ensure navRoutes.generated.ts includes route: "${navRoute}"`);
+  return result;
+}
+function navRouteToApiPath(navRoute) {
+  return `/api/${navRoute.replace(/\./g, "/")}`;
+}
+function generateApiClient(name, nameLower, navRoute, apiPath, methods) {
+  const template = `/**
+ * ${name} API Client
+ *
+ * Auto-generated by SmartStack MCP - DO NOT EDIT MANUALLY
+ * NavRoute: ${navRoute}
+ * API Path: ${apiPath}
+ */
 
-## Overview
+import { getRoute } from '../routes/navRoutes.generated';
+import { apiClient } from '../lib/apiClient';
+import type {
+  ${name},
+  ${name}CreateRequest,
+  ${name}UpdateRequest,
+  ${name}ListResponse,
+  PaginatedRequest,
+  PaginatedResponse
+} from '../types/${nameLower}';
+
+const ROUTE = getRoute('${navRoute}');
+
+export const ${nameLower}Api = {
+${methods.includes("getAll") ? `  /**
+   * Get all ${name}s with pagination
+   */
+  async getAll(params?: PaginatedRequest): Promise<PaginatedResponse<${name}>> {
+    const response = await apiClient.get<${name}ListResponse>(ROUTE.api, { params });
+    return response.data;
+  },
+` : ""}
+${methods.includes("getById") ? `  /**
+   * Get ${name} by ID
+   */
+  async getById(id: string): Promise<${name}> {
+    const response = await apiClient.get<${name}>(\`\${ROUTE.api}/\${id}\`);
+    return response.data;
+  },
+` : ""}
+${methods.includes("create") ? `  /**
+   * Create new ${name}
+   */
+  async create(data: ${name}CreateRequest): Promise<${name}> {
+    const response = await apiClient.post<${name}>(ROUTE.api, data);
+    return response.data;
+  },
+` : ""}
+${methods.includes("update") ? `  /**
+   * Update existing ${name}
+   */
+  async update(id: string, data: ${name}UpdateRequest): Promise<${name}> {
+    const response = await apiClient.put<${name}>(\`\${ROUTE.api}/\${id}\`, data);
+    return response.data;
+  },
+` : ""}
+${methods.includes("delete") ? `  /**
+   * Delete ${name}
+   */
+  async delete(id: string): Promise<void> {
+    await apiClient.delete(\`\${ROUTE.api}/\${id}\`);
+  },
+` : ""}
+${methods.includes("search") ? `  /**
+   * Search ${name}s
+   */
+  async search(query: string, params?: PaginatedRequest): Promise<PaginatedResponse<${name}>> {
+    const response = await apiClient.get<${name}ListResponse>(\`\${ROUTE.api}/search\`, {
+      params: { q: query, ...params }
+    });
+    return response.data;
+  },
+` : ""}
+${methods.includes("export") ? `  /**
+   * Export ${name}s to file
+   */
+  async export(format: 'csv' | 'xlsx' | 'pdf' = 'xlsx'): Promise<Blob> {
+    const response = await apiClient.get(\`\${ROUTE.api}/export\`, {
+      params: { format },
+      responseType: 'blob'
+    });
+    return response.data;
+  },
+` : ""}
+  /**
+   * Get the NavRoute for this API
+   */
+  getRoute() {
+    return ROUTE;
+  },
+};
 
-This document describes the mandatory conventions for extending the SmartStack/AtlasHub platform.
-Following these conventions ensures compatibility and prevents conflicts.
+export default ${nameLower}Api;
+`;
+  return template;
+}
+function generateTypes(name) {
+  return `/**
+ * ${name} Types
+ *
+ * Auto-generated by SmartStack MCP - Customize as needed
+ */
 
----
+export interface ${name} {
+  id: string;
+  code: string;
+  name?: string;
+  description?: string;
+  isActive: boolean;
+  createdAt: string;
+  createdBy: string;
+  updatedAt?: string;
+  updatedBy?: string;
+}
 
-## 1. Database Conventions
+export interface ${name}CreateRequest {
+  code: string;
+  name?: string;
+  description?: string;
+}
 
-### SQL Schemas
+export interface ${name}UpdateRequest {
+  code?: string;
+  name?: string;
+  description?: string;
+  isActive?: boolean;
+}
 
-SmartStack uses SQL Server schemas to separate platform tables from client extensions:
+export interface ${name}ListResponse {
+  items: ${name}[];
+  totalCount: number;
+  pageSize: number;
+  currentPage: number;
+  totalPages: number;
+}
 
-| Schema | Usage | Description |
-|--------|-------|-------------|
-| \`${schemas.platform}\` | SmartStack platform | All native SmartStack tables |
-| \`${schemas.extensions}\` | Client extensions | Custom tables added by clients |
+export interface PaginatedRequest {
+  page?: number;
+  pageSize?: number;
+  sortBy?: string;
+  sortDirection?: 'asc' | 'desc';
+  filter?: string;
+}
 
-### Domain Table Prefixes
+export interface PaginatedResponse<T> {
+  items: T[];
+  totalCount: number;
+  pageSize: number;
+  currentPage: number;
+  totalPages: number;
+}
+`;
+}
+function generateHook(name, nameLower, methods) {
+  return `/**
+ * ${name} React Query Hooks
+ *
+ * Auto-generated by SmartStack MCP - DO NOT EDIT MANUALLY
+ */
 
-Tables are organized by domain using prefixes:
+import { useQuery, useMutation, useQueryClient, UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { ${nameLower}Api } from '../services/api/${nameLower}';
+import type { ${name}, ${name}CreateRequest, ${name}UpdateRequest, PaginatedRequest, PaginatedResponse } from '../types/${nameLower}';
 
-| Prefix | Domain | Example Tables |
-|--------|--------|----------------|
+const QUERY_KEY = '${nameLower}s';
+
+${methods.includes("getAll") ? `/**
+ * Hook to fetch paginated ${name} list
+ */
+export function use${name}List(
+  params?: PaginatedRequest,
+  options?: Omit<UseQueryOptions<PaginatedResponse<${name}>>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: [QUERY_KEY, 'list', params],
+    queryFn: () => ${nameLower}Api.getAll(params),
+    ...options,
+  });
+}
+` : ""}
+${methods.includes("getById") ? `/**
+ * Hook to fetch single ${name} by ID
+ */
+export function use${name}(
+  id: string | undefined,
+  options?: Omit<UseQueryOptions<${name}>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: [QUERY_KEY, 'detail', id],
+    queryFn: () => ${nameLower}Api.getById(id!),
+    enabled: !!id,
+    ...options,
+  });
+}
+` : ""}
+${methods.includes("create") ? `/**
+ * Hook to create new ${name}
+ */
+export function use${name}Create(
+  options?: UseMutationOptions<${name}, Error, ${name}CreateRequest>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: ${name}CreateRequest) => ${nameLower}Api.create(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [QUERY_KEY] });
+    },
+    ...options,
+  });
+}
+` : ""}
+${methods.includes("update") ? `/**
+ * Hook to update existing ${name}
+ */
+export function use${name}Update(
+  options?: UseMutationOptions<${name}, Error, { id: string; data: ${name}UpdateRequest }>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ id, data }) => ${nameLower}Api.update(id, data),
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: [QUERY_KEY] });
+      queryClient.invalidateQueries({ queryKey: [QUERY_KEY, 'detail', id] });
+    },
+    ...options,
+  });
+}
+` : ""}
+${methods.includes("delete") ? `/**
+ * Hook to delete ${name}
+ */
+export function use${name}Delete(
+  options?: UseMutationOptions<void, Error, string>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (id: string) => ${nameLower}Api.delete(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [QUERY_KEY] });
+    },
+    ...options,
+  });
+}
+` : ""}
+${methods.includes("search") ? `/**
+ * Hook to search ${name}s
+ */
+export function use${name}Search(
+  query: string,
+  params?: PaginatedRequest,
+  options?: Omit<UseQueryOptions<PaginatedResponse<${name}>>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: [QUERY_KEY, 'search', query, params],
+    queryFn: () => ${nameLower}Api.search(query, params),
+    enabled: query.length >= 2,
+    ...options,
+  });
+}
+` : ""}
+`;
+}
+function formatResult4(result, input) {
+  const lines = [];
+  lines.push(`# Scaffold API Client: ${input.name}`);
+  lines.push("");
+  if (input.options?.dryRun) {
+    lines.push("> **DRY RUN** - No files were written");
+    lines.push("");
+  }
+  lines.push(`## NavRoute Integration`);
+  lines.push("");
+  lines.push(`- **NavRoute**: \`${input.navRoute}\``);
+  lines.push(`- **API Path**: \`${navRouteToApiPath(input.navRoute)}\``);
+  lines.push(`- **Methods**: ${input.methods.join(", ")}`);
+  lines.push("");
+  lines.push("## Generated Files");
+  lines.push("");
+  for (const file of result.files) {
+    const relativePath = file.path.replace(/\\/g, "/").split("/src/").pop() || file.path;
+    lines.push(`### ${relativePath}`);
+    lines.push("");
+    lines.push("```typescript");
+    lines.push(file.content.substring(0, 1500) + (file.content.length > 1500 ? "\n// ... (truncated)" : ""));
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Next Steps");
+  lines.push("");
+  for (const instruction of result.instructions) {
+    lines.push(`- ${instruction}`);
+  }
+  lines.push("");
+  lines.push("## Required Setup");
+  lines.push("");
+  lines.push("1. Ensure `navRoutes.generated.ts` exists (run `scaffold_routes`)");
+  lines.push("2. Configure `apiClient` with base URL and auth interceptors");
+  lines.push("3. Install dependencies: `npm install @tanstack/react-query axios`");
+  return lines.join("\n");
+}
+
+// src/tools/scaffold-routes.ts
+import path16 from "path";
+import { glob as glob3 } from "glob";
+var scaffoldRoutesTool = {
+  name: "scaffold_routes",
+  description: `Generate React Router configuration from backend NavRoute attributes.
+
+Creates:
+- navRoutes.generated.ts: Registry of all routes with API paths and permissions
+- routes.tsx: React Router configuration with nested routes
+- Layout components (optional)
+
+Example:
+  scaffold_routes source="controllers" scope="all"
+
+Scans backend controllers for [NavRoute("context.application.module")] attributes
+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"],
+        default: "controllers",
+        description: "Source for route discovery"
+      },
+      scope: {
+        type: "string",
+        enum: ["all", "platform", "business", "extensions"],
+        default: "all",
+        description: "Scope of routes to generate"
+      },
+      options: {
+        type: "object",
+        properties: {
+          outputPath: { type: "string", description: "Custom output path" },
+          includeLayouts: { type: "boolean", default: true },
+          includeGuards: { type: "boolean", default: true },
+          generateRegistry: { type: "boolean", default: true },
+          dryRun: { type: "boolean", default: false }
+        }
+      }
+    }
+  }
+};
+async function handleScaffoldRoutes(args, config) {
+  const input = ScaffoldRoutesInputSchema.parse(args);
+  logger.info("Scaffolding routes", { source: input.source, scope: input.scope });
+  const result = await scaffoldRoutes(input, config);
+  return formatResult5(result, input);
+}
+async function scaffoldRoutes(input, config) {
+  const result = {
+    success: true,
+    files: [],
+    instructions: []
+  };
+  const { source, scope, options } = input;
+  const dryRun = options?.dryRun ?? false;
+  const includeLayouts = options?.includeLayouts ?? true;
+  const includeGuards = options?.includeGuards ?? true;
+  const generateRegistry = options?.generateRegistry ?? true;
+  const projectRoot = input.path || config.smartstack.projectPath;
+  const structure = await findSmartStackStructure(projectRoot);
+  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;
+    result.instructions.push("No NavRoute attributes found in controllers");
+    return result;
+  }
+  if (generateRegistry) {
+    const registryContent = generateNavRouteRegistry(navRoutes);
+    const registryFile = path16.join(routesPath, "navRoutes.generated.ts");
+    if (!dryRun) {
+      await ensureDirectory(routesPath);
+      await writeText(registryFile, registryContent);
+    }
+    result.files.push({ path: registryFile, content: registryContent, type: "created" });
+  }
+  const routerContent = generateRouterConfig(navRoutes, includeGuards);
+  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 = 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 = path16.join(layoutsPath, `${capitalize(context)}Layout.tsx`);
+      if (!dryRun) {
+        await ensureDirectory(layoutsPath);
+        await writeText(layoutFile, layoutContent);
+      }
+      result.files.push({ path: layoutFile, content: layoutContent, type: "created" });
+    }
+  }
+  if (includeGuards) {
+    const guardsContent = generateRouteGuards();
+    const guardsFile = path16.join(routesPath, "guards.tsx");
+    if (!dryRun) {
+      await writeText(guardsFile, guardsContent);
+    }
+    result.files.push({ path: guardsFile, content: guardsContent, type: "created" });
+  }
+  result.instructions.push(`Generated ${navRoutes.length} routes from ${source}`);
+  result.instructions.push('Import routes: import { router } from "./routes";');
+  result.instructions.push("Use with RouterProvider: <RouterProvider router={router} />");
+  return result;
+}
+async function discoverNavRoutes(structure, scope) {
+  const routes = [];
+  const apiPath = structure.api;
+  if (!apiPath) {
+    logger.warn("No API project found");
+    return routes;
+  }
+  const controllerFiles = await glob3("**/*Controller.cs", {
+    cwd: apiPath,
+    absolute: true,
+    ignore: ["**/obj/**", "**/bin/**"]
+  });
+  for (const file of controllerFiles) {
+    try {
+      const content = await readText(file);
+      const navRouteMatch = content.match(/\[NavRoute\s*\(\s*"([^"]+)"(?:\s*,\s*Suffix\s*=\s*"([^"]+)")?\s*\)\]/);
+      if (navRouteMatch) {
+        const navRoute = navRouteMatch[1];
+        const suffix = navRouteMatch[2];
+        const context = navRoute.split(".")[0];
+        if (scope !== "all" && context !== scope) {
+          continue;
+        }
+        const controllerMatch = path16.basename(file).match(/(.+)Controller\.cs$/);
+        const controllerName = controllerMatch ? controllerMatch[1] : "Unknown";
+        const methods = [];
+        if (content.includes("[HttpGet]")) methods.push("GET");
+        if (content.includes("[HttpPost]")) methods.push("POST");
+        if (content.includes("[HttpPut]")) methods.push("PUT");
+        if (content.includes("[HttpDelete]")) methods.push("DELETE");
+        if (content.includes("[HttpPatch]")) methods.push("PATCH");
+        const permissions = [];
+        const authorizeMatches = content.matchAll(/\[Authorize\s*\(\s*[^)]*Policy\s*=\s*"([^"]+)"/g);
+        for (const match of authorizeMatches) {
+          permissions.push(match[1]);
+        }
+        const fullNavRoute = suffix ? `${navRoute}.${suffix}` : navRoute;
+        routes.push({
+          navRoute: fullNavRoute,
+          apiPath: `/api/${navRoute.replace(/\./g, "/")}${suffix ? `/${suffix}` : ""}`,
+          webPath: `/${navRoute.replace(/\./g, "/")}${suffix ? `/${suffix}` : ""}`,
+          permissions,
+          controller: controllerName,
+          methods
+        });
+      }
+    } catch {
+      logger.debug(`Failed to parse controller: ${file}`);
+    }
+  }
+  return routes.sort((a, b) => a.navRoute.localeCompare(b.navRoute));
+}
+function generateNavRouteRegistry(routes) {
+  const lines = [
+    "/**",
+    " * NavRoute Registry",
+    " *",
+    " * Auto-generated by SmartStack MCP - DO NOT EDIT MANUALLY",
+    " * Run `scaffold_routes` to regenerate",
+    " */",
+    "",
+    "export interface NavRoute {",
+    "  navRoute: string;",
+    "  api: string;",
+    "  web: string;",
+    "  permissions: string[];",
+    "  controller?: string;",
+    "  methods: string[];",
+    "}",
+    "",
+    "export const ROUTES: Record<string, NavRoute> = {"
+  ];
+  for (const route of routes) {
+    lines.push(`  '${route.navRoute}': {`);
+    lines.push(`    navRoute: '${route.navRoute}',`);
+    lines.push(`    api: '${route.apiPath}',`);
+    lines.push(`    web: '${route.webPath}',`);
+    lines.push(`    permissions: [${route.permissions.map((p) => `'${p}'`).join(", ")}],`);
+    if (route.controller) {
+      lines.push(`    controller: '${route.controller}',`);
+    }
+    lines.push(`    methods: [${route.methods.map((m) => `'${m}'`).join(", ")}],`);
+    lines.push("  },");
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * Get route configuration by NavRoute path");
+  lines.push(" */");
+  lines.push("export function getRoute(navRoute: string): NavRoute {");
+  lines.push("  const route = ROUTES[navRoute];");
+  lines.push("  if (!route) {");
+  lines.push("    throw new Error(`Route not found: ${navRoute}`);");
+  lines.push("  }");
+  lines.push("  return route;");
+  lines.push("}");
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * Check if user has permission for route");
+  lines.push(" */");
+  lines.push("export function hasRoutePermission(navRoute: string, userPermissions: string[]): boolean {");
+  lines.push("  const route = ROUTES[navRoute];");
+  lines.push("  if (!route || route.permissions.length === 0) return true;");
+  lines.push("  return route.permissions.some(p => userPermissions.includes(p));");
+  lines.push("}");
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * Get all routes for a context");
+  lines.push(" */");
+  lines.push("export function getRoutesByContext(context: string): NavRoute[] {");
+  lines.push("  return Object.values(ROUTES).filter(r => r.navRoute.startsWith(`${context}.`));");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateRouterConfig(routes, includeGuards) {
+  const routeTree = buildRouteTree(routes);
+  const lines = [
+    "/**",
+    " * React Router Configuration",
+    " *",
+    " * Auto-generated by SmartStack MCP - DO NOT EDIT MANUALLY",
+    " */",
+    "",
+    "import { createBrowserRouter, RouteObject } from 'react-router-dom';",
+    "import { ROUTES } from './navRoutes.generated';"
+  ];
+  if (includeGuards) {
+    lines.push("import { ProtectedRoute, PermissionGuard } from './guards';");
+  }
+  const contexts = Object.keys(routeTree);
+  for (const context of contexts) {
+    lines.push(`import { ${capitalize(context)}Layout } from '../layouts/${capitalize(context)}Layout';`);
+  }
+  lines.push("");
+  lines.push("// Page imports - customize these paths");
+  for (const route of routes) {
+    const pageName = route.navRoute.split(".").map(capitalize).join("");
+    lines.push(`// import { ${pageName}Page } from '../pages/${pageName}Page';`);
+  }
+  lines.push("");
+  lines.push("const routes: RouteObject[] = [");
+  for (const [context, applications] of Object.entries(routeTree)) {
+    lines.push("  {");
+    lines.push(`    path: '${context}',`);
+    lines.push(`    element: <${capitalize(context)}Layout />,`);
+    lines.push("    children: [");
+    for (const [app, modules] of Object.entries(applications)) {
+      lines.push("      {");
+      lines.push(`        path: '${app}',`);
+      lines.push("        children: [");
+      for (const route of modules) {
+        const modulePath = route.navRoute.split(".").slice(2).join("/");
+        const pageName = route.navRoute.split(".").map(capitalize).join("");
+        if (includeGuards && route.permissions.length > 0) {
+          lines.push("          {");
+          lines.push(`            path: '${modulePath || ""}',`);
+          lines.push(`            element: (`);
+          lines.push(`              <PermissionGuard permissions={ROUTES['${route.navRoute}'].permissions}>`);
+          lines.push(`                {/* <${pageName}Page /> */}`);
+          lines.push(`                <div>TODO: ${pageName}Page</div>`);
+          lines.push(`              </PermissionGuard>`);
+          lines.push(`            ),`);
+          lines.push("          },");
+        } else {
+          lines.push("          {");
+          lines.push(`            path: '${modulePath || ""}',`);
+          lines.push(`            element: <div>TODO: ${pageName}Page</div>,`);
+          lines.push("          },");
+        }
+      }
+      lines.push("        ],");
+      lines.push("      },");
+    }
+    lines.push("    ],");
+    lines.push("  },");
+  }
+  lines.push("];");
+  lines.push("");
+  lines.push("export const router = createBrowserRouter(routes);");
+  lines.push("");
+  lines.push("export default router;");
+  lines.push("");
+  return lines.join("\n");
+}
+function buildRouteTree(routes) {
+  const tree = {};
+  for (const route of routes) {
+    const parts = route.navRoute.split(".");
+    const context = parts[0];
+    const app = parts[1] || "default";
+    if (!tree[context]) {
+      tree[context] = {};
+    }
+    if (!tree[context][app]) {
+      tree[context][app] = [];
+    }
+    tree[context][app].push(route);
+  }
+  return tree;
+}
+function generateLayout(context) {
+  const contextCapitalized = capitalize(context);
+  return `/**
+ * ${contextCapitalized} Layout
+ *
+ * Auto-generated by SmartStack MCP - Customize as needed
+ */
+
+import React from 'react';
+import { Outlet, Link, useLocation } from 'react-router-dom';
+import { ROUTES, getRoutesByContext } from '../routes/navRoutes.generated';
+
+export const ${contextCapitalized}Layout: React.FC = () => {
+  const location = useLocation();
+  const contextRoutes = getRoutesByContext('${context}');
+
+  return (
+    <div className="flex h-screen bg-gray-100">
+      {/* Sidebar */}
+      <aside className="w-64 bg-white shadow-sm">
+        <div className="p-4 border-b">
+          <h1 className="text-xl font-semibold text-gray-900">${contextCapitalized}</h1>
+        </div>
+        <nav className="p-4">
+          <ul className="space-y-2">
+            {contextRoutes.map((route) => (
+              <li key={route.navRoute}>
+                <Link
+                  to={route.web}
+                  className={\`block px-3 py-2 rounded-md \${
+                    location.pathname === route.web
+                      ? 'bg-blue-50 text-blue-700'
+                      : 'text-gray-700 hover:bg-gray-50'
+                  }\`}
+                >
+                  {route.navRoute.split('.').pop()}
+                </Link>
+              </li>
+            ))}
+          </ul>
+        </nav>
+      </aside>
+
+      {/* Main content */}
+      <main className="flex-1 overflow-auto">
+        <div className="p-6">
+          <Outlet />
+        </div>
+      </main>
+    </div>
+  );
+};
+
+export default ${contextCapitalized}Layout;
+`;
+}
+function generateRouteGuards() {
+  return `/**
+ * Route Guards
+ *
+ * Auto-generated by SmartStack MCP - Customize as needed
+ */
+
+import React from 'react';
+import { Navigate, useLocation } from 'react-router-dom';
+
+interface ProtectedRouteProps {
+  children: React.ReactNode;
+  redirectTo?: string;
+}
+
+interface PermissionGuardProps {
+  children: React.ReactNode;
+  permissions: string[];
+  fallback?: React.ReactNode;
+}
+
+/**
+ * Protect routes that require authentication
+ */
+export const ProtectedRoute: React.FC<ProtectedRouteProps> = ({
+  children,
+  redirectTo = '/login'
+}) => {
+  const location = useLocation();
+
+  // TODO: Replace with your auth hook
+  const isAuthenticated = true; // useAuth().isAuthenticated;
+
+  if (!isAuthenticated) {
+    return <Navigate to={redirectTo} state={{ from: location }} replace />;
+  }
+
+  return <>{children}</>;
+};
+
+/**
+ * Guard routes based on user permissions
+ */
+export const PermissionGuard: React.FC<PermissionGuardProps> = ({
+  children,
+  permissions,
+  fallback
+}) => {
+  // TODO: Replace with your auth hook
+  const userPermissions: string[] = []; // useAuth().permissions;
+
+  const hasPermission = permissions.length === 0 ||
+    permissions.some(p => userPermissions.includes(p));
+
+  if (!hasPermission) {
+    if (fallback) return <>{fallback}</>;
+    return (
+      <div className="flex items-center justify-center h-64">
+        <div className="text-center">
+          <h2 className="text-xl font-semibold text-gray-900">Access Denied</h2>
+          <p className="mt-2 text-gray-600">
+            You don't have permission to access this page.
+          </p>
+          <p className="mt-1 text-sm text-gray-500">
+            Required: {permissions.join(', ')}
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  return <>{children}</>;
+};
+`;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatResult5(result, input) {
+  const lines = [];
+  lines.push("# Scaffold Routes");
+  lines.push("");
+  if (input.options?.dryRun) {
+    lines.push("> **DRY RUN** - No files were written");
+    lines.push("");
+  }
+  lines.push("## Configuration");
+  lines.push("");
+  lines.push(`- **Source**: ${input.source}`);
+  lines.push(`- **Scope**: ${input.scope}`);
+  lines.push("");
+  lines.push("## Generated Files");
+  lines.push("");
+  for (const file of result.files) {
+    const relativePath = file.path.replace(/\\/g, "/").split("/src/").pop() || file.path;
+    lines.push(`### ${relativePath}`);
+    lines.push("");
+    lines.push("```tsx");
+    lines.push(file.content.substring(0, 2e3) + (file.content.length > 2e3 ? "\n// ... (truncated)" : ""));
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Instructions");
+  lines.push("");
+  for (const instruction of result.instructions) {
+    lines.push(`- ${instruction}`);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/validate-frontend-routes.ts
+import path17 from "path";
+import { glob as glob4 } from "glob";
+var validateFrontendRoutesTool = {
+  name: "validate_frontend_routes",
+  description: `Validate frontend routes against backend NavRoute attributes.
+
+Checks:
+- navRoutes.generated.ts exists and is up-to-date
+- API clients use correct NavRoute paths
+- React Router configuration matches backend routes
+- Permission configurations are synchronized
+
+Example:
+  validate_frontend_routes scope="all"
+
+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"],
+        default: "all",
+        description: "Scope of validation"
+      },
+      options: {
+        type: "object",
+        properties: {
+          fix: { type: "boolean", default: false, description: "Auto-fix minor issues" },
+          strict: { type: "boolean", default: false, description: "Fail on warnings" }
+        }
+      }
+    }
+  }
+};
+async function handleValidateFrontendRoutes(args, config) {
+  const input = ValidateFrontendRoutesInputSchema.parse(args);
+  logger.info("Validating frontend routes", { scope: input.scope });
+  const result = await validateFrontendRoutes(input, config);
+  return formatResult6(result, input);
+}
+async function validateFrontendRoutes(input, config) {
+  const result = {
+    valid: true,
+    registry: {
+      exists: false,
+      routeCount: 0,
+      outdated: []
+    },
+    apiClients: {
+      total: 0,
+      valid: 0,
+      issues: []
+    },
+    routes: {
+      total: 0,
+      orphaned: [],
+      missing: []
+    },
+    recommendations: []
+  };
+  const { scope } = input;
+  const projectRoot = input.path || config.smartstack.projectPath;
+  const structure = await findSmartStackStructure(projectRoot);
+  const webPath = structure.web || path17.join(projectRoot, "web");
+  const backendRoutes = await discoverBackendNavRoutes(structure);
+  if (scope === "all" || scope === "registry") {
+    await validateRegistry(webPath, backendRoutes, result);
+  }
+  if (scope === "all" || scope === "api-clients") {
+    await validateApiClients(webPath, backendRoutes, result);
+  }
+  if (scope === "all" || scope === "routes") {
+    await validateRoutes(webPath, backendRoutes, result);
+  }
+  generateRecommendations2(result);
+  result.valid = result.apiClients.issues.filter((i) => i.severity === "error").length === 0 && result.routes.missing.length === 0 && result.registry.exists;
+  return result;
+}
+async function discoverBackendNavRoutes(structure) {
+  const routes = [];
+  const apiPath = structure.api;
+  if (!apiPath) {
+    return routes;
+  }
+  const controllerFiles = await glob4("**/*Controller.cs", {
+    cwd: apiPath,
+    absolute: true,
+    ignore: ["**/obj/**", "**/bin/**"]
+  });
+  for (const file of controllerFiles) {
+    try {
+      const content = await readText(file);
+      const navRouteMatch = content.match(/\[NavRoute\s*\(\s*"([^"]+)"(?:\s*,\s*Suffix\s*=\s*"([^"]+)")?\s*\)\]/);
+      if (navRouteMatch) {
+        const navRoute = navRouteMatch[1];
+        const suffix = navRouteMatch[2];
+        const fullNavRoute = suffix ? `${navRoute}.${suffix}` : navRoute;
+        const controllerMatch = path17.basename(file).match(/(.+)Controller\.cs$/);
+        const controllerName = controllerMatch ? controllerMatch[1] : "Unknown";
+        const methods = [];
+        if (content.includes("[HttpGet]")) methods.push("GET");
+        if (content.includes("[HttpPost]")) methods.push("POST");
+        if (content.includes("[HttpPut]")) methods.push("PUT");
+        if (content.includes("[HttpDelete]")) methods.push("DELETE");
+        const permissions = [];
+        const authorizeMatches = content.matchAll(/\[Authorize\s*\(\s*[^)]*Policy\s*=\s*"([^"]+)"/g);
+        for (const match of authorizeMatches) {
+          permissions.push(match[1]);
+        }
+        routes.push({
+          navRoute: fullNavRoute,
+          apiPath: `/api/${navRoute.replace(/\./g, "/")}${suffix ? `/${suffix}` : ""}`,
+          webPath: `/${navRoute.replace(/\./g, "/")}${suffix ? `/${suffix}` : ""}`,
+          permissions,
+          controller: controllerName,
+          methods
+        });
+      }
+    } catch {
+      logger.debug(`Failed to parse controller: ${file}`);
+    }
+  }
+  return routes;
+}
+async function validateRegistry(webPath, backendRoutes, result) {
+  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");
+    return;
+  }
+  result.registry.exists = true;
+  try {
+    const content = await readText(registryPath);
+    const routeMatches = content.matchAll(/'([a-z.]+)':\s*\{/g);
+    const registryRoutes = /* @__PURE__ */ new Set();
+    for (const match of routeMatches) {
+      registryRoutes.add(match[1]);
+    }
+    result.registry.routeCount = registryRoutes.size;
+    for (const backendRoute of backendRoutes) {
+      if (!registryRoutes.has(backendRoute.navRoute)) {
+        result.registry.outdated.push(backendRoute.navRoute);
+      }
+    }
+    for (const registryRoute of registryRoutes) {
+      if (!backendRoutes.find((r) => r.navRoute === registryRoute)) {
+        result.registry.outdated.push(`${registryRoute} (removed from backend)`);
+      }
+    }
+  } catch {
+    result.registry.exists = false;
+  }
+}
+async function validateApiClients(webPath, backendRoutes, result) {
+  const servicesPath = path17.join(webPath, "src", "services", "api");
+  const clientFiles = await glob4("**/*.ts", {
+    cwd: servicesPath,
+    absolute: true,
+    ignore: ["**/index.ts"]
+  });
+  result.apiClients.total = clientFiles.length;
+  for (const file of clientFiles) {
+    try {
+      const content = await readText(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*['"`]([^'"`]+)['"`]/);
+        if (hardcodedMatch) {
+          result.apiClients.issues.push({
+            type: "invalid-path",
+            severity: "warning",
+            file: relativePath,
+            message: `Hardcoded API path: ${hardcodedMatch[2]}`,
+            suggestion: "Use getRoute() from navRoutes.generated.ts instead"
+          });
+        }
+      } else {
+        const navRouteMatch = content.match(/getRoute\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/);
+        if (navRouteMatch) {
+          const navRoute = navRouteMatch[1];
+          const backendRoute = backendRoutes.find((r) => r.navRoute === navRoute);
+          if (!backendRoute) {
+            result.apiClients.issues.push({
+              type: "missing-route",
+              severity: "error",
+              file: relativePath,
+              navRoute,
+              message: `NavRoute "${navRoute}" not found in backend controllers`,
+              suggestion: "Verify the NavRoute path or update the backend controller"
+            });
+          } else {
+            result.apiClients.valid++;
+          }
+        }
+      }
+    } catch {
+      logger.debug(`Failed to parse API client: ${file}`);
+    }
+  }
+}
+async function validateRoutes(webPath, backendRoutes, result) {
+  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);
+    return;
+  }
+  try {
+    const content = await readText(routesPath);
+    const pathMatches = content.matchAll(/path:\s*['"`]([^'"`]+)['"`]/g);
+    const frontendPaths = /* @__PURE__ */ new Set();
+    for (const match of pathMatches) {
+      frontendPaths.add(match[1]);
+    }
+    result.routes.total = frontendPaths.size;
+    for (const backendRoute of backendRoutes) {
+      const webPath2 = backendRoute.webPath.replace(/^\//, "");
+      const parts = webPath2.split("/");
+      let found = false;
+      for (const pathPart of parts) {
+        if (frontendPaths.has(pathPart)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found && parts.length > 0) {
+        result.routes.missing.push(backendRoute.navRoute);
+      }
+    }
+    for (const frontendPath of frontendPaths) {
+      if (frontendPath === "*" || frontendPath === "" || frontendPath.startsWith(":")) {
+        continue;
+      }
+      const matchingBackend = backendRoutes.find(
+        (r) => r.webPath.includes(frontendPath) || r.navRoute.includes(frontendPath)
+      );
+      if (!matchingBackend) {
+        result.routes.orphaned.push(frontendPath);
+      }
+    }
+  } catch {
+    result.routes.total = 0;
+    result.routes.missing = backendRoutes.map((r) => r.navRoute);
+  }
+}
+function generateRecommendations2(result) {
+  if (!result.registry.exists) {
+    result.recommendations.push('Run `scaffold_routes source="controllers"` to generate route registry');
+  } else if (result.registry.outdated.length > 0) {
+    result.recommendations.push(`Registry is outdated: ${result.registry.outdated.length} routes need sync. Run \`scaffold_routes\``);
+  }
+  if (result.apiClients.issues.length > 0) {
+    const hardcoded = result.apiClients.issues.filter((i) => i.type === "invalid-path").length;
+    const missing = result.apiClients.issues.filter((i) => i.type === "missing-route").length;
+    if (hardcoded > 0) {
+      result.recommendations.push(`${hardcoded} API clients use hardcoded paths. Migrate to getRoute()`);
+    }
+    if (missing > 0) {
+      result.recommendations.push(`${missing} API clients reference non-existent NavRoutes`);
+    }
+  }
+  if (result.routes.missing.length > 0) {
+    result.recommendations.push(`${result.routes.missing.length} backend routes have no frontend counterpart`);
+  }
+  if (result.routes.orphaned.length > 0) {
+    result.recommendations.push(`${result.routes.orphaned.length} frontend routes have no backend NavRoute`);
+  }
+  if (result.valid && result.recommendations.length === 0) {
+    result.recommendations.push("All routes are synchronized between frontend and backend");
+  }
+}
+function formatResult6(result, _input) {
+  const lines = [];
+  const statusIcon = result.valid ? "\u2705" : "\u274C";
+  lines.push(`# Frontend Route Validation ${statusIcon}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Valid | ${result.valid ? "Yes" : "No"} |`);
+  lines.push(`| Registry Exists | ${result.registry.exists ? "Yes" : "No"} |`);
+  lines.push(`| Registry Routes | ${result.registry.routeCount} |`);
+  lines.push(`| API Clients | ${result.apiClients.valid}/${result.apiClients.total} valid |`);
+  lines.push(`| Frontend Routes | ${result.routes.total} |`);
+  lines.push(`| Missing Routes | ${result.routes.missing.length} |`);
+  lines.push(`| Orphaned Routes | ${result.routes.orphaned.length} |`);
+  lines.push("");
+  if (result.registry.outdated.length > 0) {
+    lines.push("## Outdated Registry Entries");
+    lines.push("");
+    for (const route of result.registry.outdated) {
+      lines.push(`- \`${route}\``);
+    }
+    lines.push("");
+  }
+  if (result.apiClients.issues.length > 0) {
+    lines.push("## API Client Issues");
+    lines.push("");
+    for (const issue of result.apiClients.issues) {
+      const icon = issue.severity === "error" ? "\u274C" : "\u26A0\uFE0F";
+      lines.push(`### ${icon} ${issue.file}`);
+      lines.push("");
+      lines.push(`- **Type**: ${issue.type}`);
+      lines.push(`- **Message**: ${issue.message}`);
+      if (issue.navRoute) {
+        lines.push(`- **NavRoute**: \`${issue.navRoute}\``);
+      }
+      lines.push(`- **Suggestion**: ${issue.suggestion}`);
+      lines.push("");
+    }
+  }
+  if (result.routes.missing.length > 0) {
+    lines.push("## Missing Frontend Routes");
+    lines.push("");
+    lines.push("These backend NavRoutes have no corresponding frontend route:");
+    lines.push("");
+    for (const route of result.routes.missing) {
+      lines.push(`- \`${route}\``);
+    }
+    lines.push("");
+  }
+  if (result.routes.orphaned.length > 0) {
+    lines.push("## Orphaned Frontend Routes");
+    lines.push("");
+    lines.push("These frontend routes have no corresponding backend NavRoute:");
+    lines.push("");
+    for (const route of result.routes.orphaned) {
+      lines.push(`- \`${route}\``);
+    }
+    lines.push("");
+  }
+  lines.push("## Recommendations");
+  lines.push("");
+  for (const rec of result.recommendations) {
+    lines.push(`- ${rec}`);
+  }
+  lines.push("");
+  lines.push("## Commands");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# Regenerate route registry");
+  lines.push('scaffold_routes source="controllers"');
+  lines.push("");
+  lines.push("# Generate API client for a specific NavRoute");
+  lines.push('scaffold_api_client navRoute="platform.administration.users" name="User"');
+  lines.push("```");
+  return lines.join("\n");
+}
+
+// src/resources/conventions.ts
+var conventionsResourceTemplate = {
+  uri: "smartstack://conventions",
+  name: "AtlasHub Conventions",
+  description: "Documentation of AtlasHub/SmartStack naming conventions, patterns, and best practices",
+  mimeType: "text/markdown"
+};
+async function getConventionsResource(config) {
+  const { schemas, tablePrefixes, codePrefixes, migrationFormat, namespaces, servicePattern } = config.conventions;
+  return `# AtlasHub SmartStack Conventions
+
+## Overview
+
+This document describes the mandatory conventions for extending the SmartStack/AtlasHub platform.
+Following these conventions ensures compatibility and prevents conflicts.
+
+---
+
+## 1. Database Conventions
+
+### SQL Schemas
+
+SmartStack uses SQL Server schemas to separate platform tables from client extensions:
+
+| Schema | Usage | Description |
+|--------|-------|-------------|
+| \`${schemas.platform}\` | SmartStack platform | All native SmartStack tables |
+| \`${schemas.extensions}\` | Client extensions | Custom tables added by clients |
+
+### Domain Table Prefixes
+
+Tables are organized by domain using prefixes:
+
+| Prefix | Domain | Example Tables |
+|--------|--------|----------------|
 | \`auth_\` | Authorization | auth_Users, auth_Roles, auth_Permissions |
 | \`nav_\` | Navigation | nav_Contexts, nav_Applications, nav_Modules |
 | \`usr_\` | User profiles | usr_Profiles, usr_Preferences |
@@ -7307,7 +8734,7 @@ Run specific or all checks:
 }
 
 // src/resources/project-info.ts
-import path14 from "path";
+import path18 from "path";
 var projectInfoResourceTemplate = {
   uri: "smartstack://project",
   name: "SmartStack Project Info",
@@ -7344,16 +8771,16 @@ async function getProjectInfoResource(config) {
   lines.push("```");
   lines.push(`${projectInfo.name}/`);
   if (structure.domain) {
-    lines.push(`\u251C\u2500\u2500 ${path14.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 ${path14.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 ${path14.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 ${path14.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`);
@@ -7366,8 +8793,8 @@ async function getProjectInfoResource(config) {
     lines.push("| Project | Path |");
     lines.push("|---------|------|");
     for (const csproj of projectInfo.csprojFiles) {
-      const name = path14.basename(csproj, ".csproj");
-      const relativePath = path14.relative(projectPath, csproj);
+      const name = path18.basename(csproj, ".csproj");
+      const relativePath = path18.relative(projectPath, csproj);
       lines.push(`| ${name} | \`${relativePath}\` |`);
     }
     lines.push("");
@@ -7377,10 +8804,10 @@ async function getProjectInfoResource(config) {
       cwd: structure.migrations,
       ignore: ["*.Designer.cs"]
     });
-    const migrations = migrationFiles.map((f) => path14.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**: \`${path14.relative(projectPath, structure.migrations)}\``);
+    lines.push(`**Location**: \`${path18.relative(projectPath, structure.migrations)}\``);
     lines.push(`**Total Migrations**: ${migrations.length}`);
     lines.push("");
     if (migrations.length > 0) {
@@ -7415,11 +8842,11 @@ async function getProjectInfoResource(config) {
   lines.push("dotnet build");
   lines.push("");
   lines.push("# Run API");
-  lines.push(`cd ${structure.api ? path14.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 ? path14.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");
@@ -7442,7 +8869,7 @@ async function getProjectInfoResource(config) {
 }
 
 // src/resources/api-endpoints.ts
-import path15 from "path";
+import path19 from "path";
 var apiEndpointsResourceTemplate = {
   uri: "smartstack://api/",
   name: "SmartStack API Endpoints",
@@ -7467,7 +8894,7 @@ async function getApiEndpointsResource(config, endpointFilter) {
 }
 async function parseController(filePath, _rootPath) {
   const content = await readText(filePath);
-  const fileName = path15.basename(filePath, ".cs");
+  const fileName = path19.basename(filePath, ".cs");
   const controllerName = fileName.replace("Controller", "");
   const endpoints = [];
   const routeMatch = content.match(/\[Route\s*\(\s*"([^"]+)"\s*\)\]/);
@@ -7614,7 +9041,7 @@ function getMethodEmoji(method) {
 }
 
 // src/resources/db-schema.ts
-import path16 from "path";
+import path20 from "path";
 var dbSchemaResourceTemplate = {
   uri: "smartstack://schema/",
   name: "SmartStack Database Schema",
@@ -7704,7 +9131,7 @@ async function parseEntity(filePath, rootPath, _config) {
     tableName,
     properties,
     relationships,
-    file: path16.relative(rootPath, filePath)
+    file: path20.relative(rootPath, filePath)
   };
 }
 async function enrichFromConfigurations(entities, infrastructurePath, _config) {
@@ -7850,7 +9277,7 @@ function formatSchema(entities, filter, _config) {
 }
 
 // src/resources/entities.ts
-import path17 from "path";
+import path21 from "path";
 var entitiesResourceTemplate = {
   uri: "smartstack://entities/",
   name: "SmartStack Entities",
@@ -7910,7 +9337,7 @@ async function parseEntitySummary(filePath, rootPath, config) {
     hasSoftDelete,
     hasRowVersion,
     file: filePath,
-    relativePath: path17.relative(rootPath, filePath)
+    relativePath: path21.relative(rootPath, filePath)
   };
 }
 function inferTableInfo(entityName, config) {
@@ -8102,7 +9529,11 @@ async function createServer() {
         scaffoldTestsTool,
         analyzeTestCoverageTool,
         validateTestConventionsTool,
-        suggestTestScenariosTool
+        suggestTestScenariosTool,
+        // Frontend Route Tools
+        scaffoldApiClientTool,
+        scaffoldRoutesTool,
+        validateFrontendRoutesTool
       ]
     };
   });
@@ -8141,6 +9572,16 @@ async function createServer() {
         case "suggest_test_scenarios":
           result = await handleSuggestTestScenarios(args, config);
           break;
+        // Frontend Route Tools
+        case "scaffold_api_client":
+          result = await handleScaffoldApiClient(args ?? {}, config);
+          break;
+        case "scaffold_routes":
+          result = await handleScaffoldRoutes(args ?? {}, config);
+          break;
+        case "validate_frontend_routes":
+          result = await handleValidateFrontendRoutes(args ?? {}, config);
+          break;
         default:
           throw new Error(`Unknown tool: ${name}`);
       }