@atlashub/smartstack-mcp 1.5.1 → 1.6.0

package/dist/index.js

@@ -82,10 +82,10 @@ 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, path21, cause) {
     super(message);
     this.operation = operation;
-    this.path = path18;
+    this.path = path21;
     this.cause = cause;
     this.name = "FileSystemError";
   }
@@ -491,6 +491,35 @@ 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({
+  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({
+  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({
+  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";
@@ -6321,6 +6350,1253 @@ function getTypeEmoji(type) {
   }
 }
 
+// src/tools/scaffold-api-client.ts
+import path14 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: {
+      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 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 = config.smartstack.projectPath;
+  const structure = await findSmartStackStructure(projectRoot);
+  const webPath = structure.web || path14.join(projectRoot, "web", "smartstack-web");
+  const servicesPath = options?.outputPath || path14.join(webPath, "src", "services", "api");
+  const hooksPath = path14.join(webPath, "src", "hooks");
+  const typesPath = path14.join(webPath, "src", "types");
+  const apiClientContent = generateApiClient(name, nameLower, navRoute, apiPath, methods);
+  const apiClientFile = path14.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 = path14.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 = path14.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}
+ */
+
+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;
+  },
+};
+
+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;
+}
+
+export interface ${name}CreateRequest {
+  code: string;
+  name?: string;
+  description?: string;
+}
+
+export interface ${name}UpdateRequest {
+  code?: string;
+  name?: string;
+  description?: string;
+  isActive?: boolean;
+}
+
+export interface ${name}ListResponse {
+  items: ${name}[];
+  totalCount: number;
+  pageSize: number;
+  currentPage: number;
+  totalPages: number;
+}
+
+export interface PaginatedRequest {
+  page?: number;
+  pageSize?: number;
+  sortBy?: string;
+  sortDirection?: 'asc' | 'desc';
+  filter?: string;
+}
+
+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
+ */
+
+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}';
+
+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 path15 from "path";
+import { glob as glob2 } 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: {
+      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 = config.smartstack.projectPath;
+  const structure = await findSmartStackStructure(projectRoot);
+  const webPath = structure.web || path15.join(projectRoot, "web", "smartstack-web");
+  const routesPath = options?.outputPath || path15.join(webPath, "src", "routes");
+  const 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 = path15.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 = path15.join(routesPath, "index.tsx");
+  if (!dryRun) {
+    await ensureDirectory(routesPath);
+    await writeText(routerFile, routerContent);
+  }
+  result.files.push({ path: routerFile, content: routerContent, type: "created" });
+  if (includeLayouts) {
+    const layoutsPath = path15.join(webPath, "src", "layouts");
+    const contexts = [...new Set(navRoutes.map((r) => r.navRoute.split(".")[0]))];
+    for (const context of contexts) {
+      const layoutContent = generateLayout(context);
+      const layoutFile = path15.join(layoutsPath, `${capitalize(context)}Layout.tsx`);
+      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 = path15.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 glob2("**/*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 = path15.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 path16 from "path";
+import { glob as glob3 } 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: {
+      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 = config.smartstack.projectPath;
+  const structure = await findSmartStackStructure(projectRoot);
+  const webPath = structure.web || path16.join(projectRoot, "web", "smartstack-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 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 fullNavRoute = suffix ? `${navRoute}.${suffix}` : navRoute;
+        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");
+        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 = path16.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 = path16.join(webPath, "src", "services", "api");
+  const clientFiles = await glob3("**/*.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 = path16.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 = path16.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",
@@ -7307,7 +8583,7 @@ Run specific or all checks:
 }
 
 // src/resources/project-info.ts
-import path14 from "path";
+import path17 from "path";
 var projectInfoResourceTemplate = {
   uri: "smartstack://project",
   name: "SmartStack Project Info",
@@ -7344,16 +8620,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 ${path17.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 ${path17.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 ${path17.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 ${path17.basename(structure.api)}/             # API layer (controllers)`);
   }
   if (structure.web) {
     lines.push(`\u2514\u2500\u2500 web/smartstack-web/      # React frontend`);
@@ -7366,8 +8642,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 = path17.basename(csproj, ".csproj");
+      const relativePath = path17.relative(projectPath, csproj);
       lines.push(`| ${name} | \`${relativePath}\` |`);
     }
     lines.push("");
@@ -7377,10 +8653,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) => path17.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**: \`${path17.relative(projectPath, structure.migrations)}\``);
     lines.push(`**Total Migrations**: ${migrations.length}`);
     lines.push("");
     if (migrations.length > 0) {
@@ -7415,11 +8691,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 ? path17.relative(projectPath, structure.api) : "SmartStack.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 ? path17.relative(projectPath, structure.web) : "web/smartstack-web"}`);
   lines.push("npm run dev");
   lines.push("");
   lines.push("# Create migration");
@@ -7442,7 +8718,7 @@ async function getProjectInfoResource(config) {
 }
 
 // src/resources/api-endpoints.ts
-import path15 from "path";
+import path18 from "path";
 var apiEndpointsResourceTemplate = {
   uri: "smartstack://api/",
   name: "SmartStack API Endpoints",
@@ -7467,7 +8743,7 @@ async function getApiEndpointsResource(config, endpointFilter) {
 }
 async function parseController(filePath, _rootPath) {
   const content = await readText(filePath);
-  const fileName = path15.basename(filePath, ".cs");
+  const fileName = path18.basename(filePath, ".cs");
   const controllerName = fileName.replace("Controller", "");
   const endpoints = [];
   const routeMatch = content.match(/\[Route\s*\(\s*"([^"]+)"\s*\)\]/);
@@ -7614,7 +8890,7 @@ function getMethodEmoji(method) {
 }
 
 // src/resources/db-schema.ts
-import path16 from "path";
+import path19 from "path";
 var dbSchemaResourceTemplate = {
   uri: "smartstack://schema/",
   name: "SmartStack Database Schema",
@@ -7704,7 +8980,7 @@ async function parseEntity(filePath, rootPath, _config) {
     tableName,
     properties,
     relationships,
-    file: path16.relative(rootPath, filePath)
+    file: path19.relative(rootPath, filePath)
   };
 }
 async function enrichFromConfigurations(entities, infrastructurePath, _config) {
@@ -7850,7 +9126,7 @@ function formatSchema(entities, filter, _config) {
 }
 
 // src/resources/entities.ts
-import path17 from "path";
+import path20 from "path";
 var entitiesResourceTemplate = {
   uri: "smartstack://entities/",
   name: "SmartStack Entities",
@@ -7910,7 +9186,7 @@ async function parseEntitySummary(filePath, rootPath, config) {
     hasSoftDelete,
     hasRowVersion,
     file: filePath,
-    relativePath: path17.relative(rootPath, filePath)
+    relativePath: path20.relative(rootPath, filePath)
   };
 }
 function inferTableInfo(entityName, config) {
@@ -8102,7 +9378,11 @@ async function createServer() {
         scaffoldTestsTool,
         analyzeTestCoverageTool,
         validateTestConventionsTool,
-        suggestTestScenariosTool
+        suggestTestScenariosTool,
+        // Frontend Route Tools
+        scaffoldApiClientTool,
+        scaffoldRoutesTool,
+        validateFrontendRoutesTool
       ]
     };
   });
@@ -8141,6 +9421,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}`);
       }