@atlashub/smartstack-mcp 1.1.0

package/dist/index.js

@@ -0,0 +1,2849 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/lib/logger.ts
+var Logger = class {
+  level = "info";
+  levels = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(level) {
+    return this.levels[level] >= this.levels[this.level];
+  }
+  formatEntry(level, message, data) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      ...data !== void 0 && { data }
+    };
+    return JSON.stringify(entry);
+  }
+  debug(message, data) {
+    if (this.shouldLog("debug")) {
+      console.error(this.formatEntry("debug", message, data));
+    }
+  }
+  info(message, data) {
+    if (this.shouldLog("info")) {
+      console.error(this.formatEntry("info", message, data));
+    }
+  }
+  warn(message, data) {
+    if (this.shouldLog("warn")) {
+      console.error(this.formatEntry("warn", message, data));
+    }
+  }
+  error(message, data) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatEntry("error", message, data));
+    }
+  }
+  // Tool execution logging
+  toolStart(toolName, args) {
+    this.info(`Tool started: ${toolName}`, { args });
+  }
+  toolEnd(toolName, success, duration) {
+    this.info(`Tool completed: ${toolName}`, { success, duration });
+  }
+  toolError(toolName, error) {
+    this.error(`Tool failed: ${toolName}`, {
+      error: error.message,
+      stack: error.stack
+    });
+  }
+};
+var logger = new Logger();
+var envLevel = process.env.LOG_LEVEL;
+if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+  logger.setLevel(envLevel);
+}
+
+// src/config.ts
+import path2 from "path";
+
+// src/utils/fs.ts
+import fs from "fs-extra";
+import path from "path";
+import { glob } from "glob";
+async function fileExists(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function ensureDirectory(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function readJson(filePath) {
+  const content = await fs.readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function readText(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+async function writeText(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function findFiles(pattern, options = {}) {
+  const { cwd = process.cwd(), ignore = [] } = options;
+  const files = await glob(pattern, {
+    cwd,
+    ignore: ["**/node_modules/**", "**/bin/**", "**/obj/**", ...ignore],
+    absolute: true,
+    nodir: true
+  });
+  return files;
+}
+
+// src/config.ts
+var defaultConfig = {
+  version: "1.0.0",
+  smartstack: {
+    projectPath: process.env.SMARTSTACK_PROJECT_PATH || "D:/SmartStack.app/02-Develop",
+    apiUrl: process.env.SMARTSTACK_API_URL || "https://localhost:5001",
+    apiEnabled: process.env.SMARTSTACK_API_ENABLED !== "false"
+  },
+  conventions: {
+    tablePrefix: {
+      core: "Core_",
+      client: "Client_"
+    },
+    migrationFormat: "YYYYMMDD_{Prefix}_NNN_{Description}",
+    namespaces: {
+      domain: "SmartStack.Domain",
+      application: "SmartStack.Application",
+      infrastructure: "SmartStack.Infrastructure",
+      api: "SmartStack.Api"
+    },
+    servicePattern: {
+      interface: "I{Name}Service",
+      implementation: "{Name}Service"
+    }
+  },
+  efcore: {
+    contexts: [
+      {
+        name: "ApplicationDbContext",
+        projectPath: "auto-detect",
+        migrationsFolder: "Migrations"
+      }
+    ],
+    validation: {
+      checkModelSnapshot: true,
+      checkMigrationOrder: true,
+      requireBuildSuccess: true
+    }
+  },
+  scaffolding: {
+    outputPath: "auto-detect",
+    templates: {
+      service: "templates/service-extension.cs.hbs",
+      entity: "templates/entity-extension.cs.hbs",
+      controller: "templates/controller.cs.hbs",
+      component: "templates/component.tsx.hbs"
+    }
+  }
+};
+var cachedConfig = null;
+async function getConfig() {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+  const configPath = path2.join(process.cwd(), "config", "default-config.json");
+  if (await fileExists(configPath)) {
+    try {
+      const fileConfig = await readJson(configPath);
+      cachedConfig = mergeConfig(defaultConfig, fileConfig);
+      logger.info("Configuration loaded from file", { path: configPath });
+    } catch (error) {
+      logger.warn("Failed to load config file, using defaults", { error });
+      cachedConfig = defaultConfig;
+    }
+  } else {
+    logger.debug("No config file found, using defaults");
+    cachedConfig = defaultConfig;
+  }
+  if (process.env.SMARTSTACK_PROJECT_PATH) {
+    cachedConfig.smartstack.projectPath = process.env.SMARTSTACK_PROJECT_PATH;
+  }
+  if (process.env.SMARTSTACK_API_URL) {
+    cachedConfig.smartstack.apiUrl = process.env.SMARTSTACK_API_URL;
+  }
+  return cachedConfig;
+}
+function mergeConfig(base, override) {
+  return {
+    ...base,
+    ...override,
+    smartstack: {
+      ...base.smartstack,
+      ...override.smartstack
+    },
+    conventions: {
+      ...base.conventions,
+      ...override.conventions,
+      tablePrefix: {
+        ...base.conventions.tablePrefix,
+        ...override.conventions?.tablePrefix
+      },
+      namespaces: {
+        ...base.conventions.namespaces,
+        ...override.conventions?.namespaces
+      },
+      servicePattern: {
+        ...base.conventions.servicePattern,
+        ...override.conventions?.servicePattern
+      }
+    },
+    efcore: {
+      ...base.efcore,
+      ...override.efcore,
+      contexts: override.efcore?.contexts || base.efcore.contexts,
+      validation: {
+        ...base.efcore.validation,
+        ...override.efcore?.validation
+      }
+    },
+    scaffolding: {
+      ...base.scaffolding,
+      ...override.scaffolding,
+      templates: {
+        ...base.scaffolding.templates,
+        ...override.scaffolding?.templates
+      }
+    }
+  };
+}
+
+// src/types/index.ts
+import { z } from "zod";
+var SmartStackConfigSchema = z.object({
+  projectPath: z.string(),
+  apiUrl: z.string().url().optional(),
+  apiEnabled: z.boolean().default(true)
+});
+var ConventionsConfigSchema = z.object({
+  schemas: z.object({
+    platform: z.string().default("core"),
+    extensions: z.string().default("extensions")
+  }),
+  tablePrefixes: z.array(z.string()).default([
+    "auth_",
+    "nav_",
+    "usr_",
+    "ai_",
+    "cfg_",
+    "wkf_",
+    "support_",
+    "entra_",
+    "ref_",
+    "loc_",
+    "lic_"
+  ]),
+  migrationFormat: z.string().default("YYYYMMDD_NNN_{Description}"),
+  namespaces: z.object({
+    domain: z.string(),
+    application: z.string(),
+    infrastructure: z.string(),
+    api: z.string()
+  }),
+  servicePattern: z.object({
+    interface: z.string().default("I{Name}Service"),
+    implementation: z.string().default("{Name}Service")
+  })
+});
+var EfCoreContextSchema = z.object({
+  name: z.string(),
+  projectPath: z.string(),
+  migrationsFolder: z.string().default("Migrations")
+});
+var EfCoreConfigSchema = z.object({
+  contexts: z.array(EfCoreContextSchema),
+  validation: z.object({
+    checkModelSnapshot: z.boolean().default(true),
+    checkMigrationOrder: z.boolean().default(true),
+    requireBuildSuccess: z.boolean().default(true)
+  })
+});
+var ScaffoldingConfigSchema = z.object({
+  outputPath: z.string(),
+  templates: z.object({
+    service: z.string(),
+    entity: z.string(),
+    controller: z.string(),
+    component: z.string()
+  })
+});
+var ConfigSchema = z.object({
+  version: z.string(),
+  smartstack: SmartStackConfigSchema,
+  conventions: ConventionsConfigSchema,
+  efcore: EfCoreConfigSchema,
+  scaffolding: ScaffoldingConfigSchema
+});
+var ValidateConventionsInputSchema = z.object({
+  path: z.string().optional().describe("Project path to validate (default: SmartStack.app path)"),
+  checks: z.array(z.enum(["tables", "migrations", "services", "namespaces", "all"])).default(["all"]).describe("Types of checks to perform")
+});
+var CheckMigrationsInputSchema = z.object({
+  projectPath: z.string().optional().describe("EF Core project path"),
+  branch: z.string().optional().describe("Git branch to check (default: current)"),
+  compareBranch: z.string().optional().describe("Branch to compare against")
+});
+var ScaffoldExtensionInputSchema = z.object({
+  type: z.enum(["service", "entity", "controller", "component"]).describe("Type of extension to scaffold"),
+  name: z.string().describe('Name of the extension (e.g., "UserProfile", "Order")'),
+  options: z.object({
+    namespace: z.string().optional().describe("Custom namespace"),
+    baseEntity: z.string().optional().describe("Base entity to extend (for entity type)"),
+    methods: z.array(z.string()).optional().describe("Methods to generate (for service type)"),
+    outputPath: z.string().optional().describe("Custom output path")
+  }).optional()
+});
+var ApiDocsInputSchema = z.object({
+  endpoint: z.string().optional().describe('Filter by endpoint path (e.g., "/api/users")'),
+  format: z.enum(["markdown", "json", "openapi"]).default("markdown").describe("Output format"),
+  controller: z.string().optional().describe("Filter by controller name")
+});
+
+// src/lib/detector.ts
+import path4 from "path";
+
+// src/utils/git.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import path3 from "path";
+var execAsync = promisify(exec);
+async function git(command, cwd) {
+  const options = cwd ? { cwd } : {};
+  const { stdout } = await execAsync(`git ${command}`, options);
+  return stdout.trim();
+}
+async function isGitRepo(cwd) {
+  const gitDir = path3.join(cwd || process.cwd(), ".git");
+  return directoryExists(gitDir);
+}
+async function getCurrentBranch(cwd) {
+  try {
+    return await git("branch --show-current", cwd);
+  } catch {
+    return null;
+  }
+}
+async function branchExists(branch, cwd) {
+  try {
+    await git(`rev-parse --verify ${branch}`, cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getFileFromBranch(branch, filePath, cwd) {
+  try {
+    return await git(`show ${branch}:${filePath}`, cwd);
+  } catch {
+    return null;
+  }
+}
+async function getDiff(fromBranch, toBranch, filePath, cwd) {
+  try {
+    const pathArg = filePath ? ` -- ${filePath}` : "";
+    return await git(`diff ${fromBranch}...${toBranch}${pathArg}`, cwd);
+  } catch {
+    return "";
+  }
+}
+
+// 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;
+  }
+}
+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;
+  }
+}
+
+// src/lib/detector.ts
+async function detectProject(projectPath) {
+  logger.debug("Detecting project info", { path: projectPath });
+  const info = {
+    name: path4.basename(projectPath),
+    version: "0.0.0",
+    isGitRepo: false,
+    hasDotNet: false,
+    hasEfCore: false,
+    hasReact: false,
+    csprojFiles: []
+  };
+  if (!await directoryExists(projectPath)) {
+    logger.warn("Project path does not exist", { path: projectPath });
+    return info;
+  }
+  info.isGitRepo = await isGitRepo(projectPath);
+  if (info.isGitRepo) {
+    info.currentBranch = await getCurrentBranch(projectPath) || void 0;
+  }
+  info.csprojFiles = await findCsprojFiles(projectPath);
+  info.hasDotNet = info.csprojFiles.length > 0;
+  if (info.hasDotNet) {
+    for (const csproj of info.csprojFiles) {
+      if (await hasEfCore(csproj)) {
+        info.hasEfCore = true;
+        info.dbContextName = await findDbContextName(path4.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 {
+    }
+  }
+  if (info.csprojFiles.length > 0) {
+    const mainCsproj = info.csprojFiles.find((f) => f.includes("SmartStack.Api")) || info.csprojFiles[0];
+    const targetFramework = await getTargetFramework(mainCsproj);
+    if (targetFramework) {
+      logger.debug("Target framework detected", { framework: targetFramework });
+    }
+  }
+  logger.info("Project detected", info);
+  return info;
+}
+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);
+    if (projectName.includes("domain")) {
+      structure.domain = projectDir;
+    } else if (projectName.includes("application")) {
+      structure.application = projectDir;
+    } else if (projectName.includes("infrastructure")) {
+      structure.infrastructure = projectDir;
+    } else if (projectName.includes("api")) {
+      structure.api = projectDir;
+    }
+  }
+  if (structure.infrastructure) {
+    const migrationsPath = path4.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;
+  }
+  return structure;
+}
+async function findEntityFiles(domainPath) {
+  const entityFiles = await findFiles("**/*.cs", { cwd: domainPath });
+  const entities = [];
+  for (const file of entityFiles) {
+    const content = await readText(file);
+    if (content.match(/public\s+(?:class|record)\s+\w+/) && content.match(/public\s+(?:int|long|Guid|string)\s+Id\s*\{/)) {
+      entities.push(file);
+    }
+  }
+  return entities;
+}
+async function findControllerFiles(apiPath) {
+  const files = await findFiles("**/*Controller.cs", { cwd: apiPath });
+  return files;
+}
+
+// src/tools/validate-conventions.ts
+import path5 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 (YYYYMMDD_NNN_*), service interfaces (I*Service), namespace structure",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Project path to validate (default: SmartStack.app path from config)"
+      },
+      checks: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: ["tables", "migrations", "services", "namespaces", "all"]
+        },
+        description: "Types of checks to perform",
+        default: ["all"]
+      }
+    }
+  }
+};
+async function handleValidateConventions(args, config) {
+  const input = ValidateConventionsInputSchema.parse(args);
+  const projectPath = input.path || config.smartstack.projectPath;
+  const checks = input.checks.includes("all") ? ["tables", "migrations", "services", "namespaces"] : input.checks;
+  logger.info("Validating conventions", { projectPath, checks });
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: [],
+    summary: ""
+  };
+  const structure = await findSmartStackStructure(projectPath);
+  if (checks.includes("tables")) {
+    await validateTablePrefixes(structure, config, result);
+  }
+  if (checks.includes("migrations")) {
+    await validateMigrationNaming(structure, config, result);
+  }
+  if (checks.includes("services")) {
+    await validateServiceInterfaces(structure, config, result);
+  }
+  if (checks.includes("namespaces")) {
+    await validateNamespaces(structure, config, result);
+  }
+  result.valid = result.errors.length === 0;
+  result.summary = generateSummary(result, checks);
+  return formatResult(result);
+}
+async function validateTablePrefixes(structure, config, result) {
+  if (!structure.infrastructure) {
+    result.warnings.push({
+      type: "warning",
+      category: "tables",
+      message: "Infrastructure project not found, skipping table validation"
+    });
+    return;
+  }
+  const configFiles = await findFiles("**/Configurations/**/*.cs", {
+    cwd: structure.infrastructure
+  });
+  const validSchemas = [config.conventions.schemas.platform, config.conventions.schemas.extensions];
+  const validPrefixes = config.conventions.tablePrefixes;
+  const schemaConstantsMap = {
+    "SchemaConstants.Core": config.conventions.schemas.platform,
+    "SchemaConstants.Extensions": config.conventions.schemas.extensions
+  };
+  for (const file of configFiles) {
+    const content = await readText(file);
+    const tableWithStringSchemaMatches = content.matchAll(/\.ToTable\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g);
+    for (const match of tableWithStringSchemaMatches) {
+      const tableName = match[1];
+      const schemaName = match[2];
+      if (!validSchemas.includes(schemaName)) {
+        result.errors.push({
+          type: "error",
+          category: "tables",
+          message: `Table "${tableName}" uses invalid schema "${schemaName}"`,
+          file: path5.relative(structure.root, file),
+          suggestion: `Use schema "${config.conventions.schemas.platform}" for SmartStack tables or "${config.conventions.schemas.extensions}" for client extensions`
+        });
+      }
+      const hasValidPrefix = validPrefixes.some((prefix) => tableName.startsWith(prefix));
+      if (!hasValidPrefix && !tableName.startsWith("__")) {
+        result.warnings.push({
+          type: "warning",
+          category: "tables",
+          message: `Table "${tableName}" does not use a standard domain prefix`,
+          file: path5.relative(structure.root, file),
+          suggestion: `Consider using a domain prefix: ${validPrefixes.slice(0, 5).join(", ")}, etc.`
+        });
+      }
+    }
+    const tableWithConstantSchemaMatches = content.matchAll(/\.ToTable\s*\(\s*"([^"]+)"\s*,\s*(SchemaConstants\.\w+)\s*\)/g);
+    for (const match of tableWithConstantSchemaMatches) {
+      const tableName = match[1];
+      const schemaConstant = match[2];
+      const resolvedSchema = schemaConstantsMap[schemaConstant];
+      if (!resolvedSchema) {
+        result.errors.push({
+          type: "error",
+          category: "tables",
+          message: `Table "${tableName}" uses unknown schema constant "${schemaConstant}"`,
+          file: path5.relative(structure.root, file),
+          suggestion: `Use SchemaConstants.Core for SmartStack tables or SchemaConstants.Extensions for client extensions`
+        });
+      }
+      const hasValidPrefix = validPrefixes.some((prefix) => tableName.startsWith(prefix));
+      if (!hasValidPrefix && !tableName.startsWith("__")) {
+        result.warnings.push({
+          type: "warning",
+          category: "tables",
+          message: `Table "${tableName}" does not use a standard domain prefix`,
+          file: path5.relative(structure.root, file),
+          suggestion: `Consider using a domain prefix: ${validPrefixes.slice(0, 5).join(", ")}, etc.`
+        });
+      }
+    }
+    const tableWithoutSchemaMatches = content.matchAll(/\.ToTable\s*\(\s*"([^"]+)"\s*\)(?!\s*,)/g);
+    for (const match of tableWithoutSchemaMatches) {
+      const tableName = match[1];
+      if (!tableName.startsWith("__")) {
+        result.errors.push({
+          type: "error",
+          category: "tables",
+          message: `Table "${tableName}" is missing schema specification`,
+          file: path5.relative(structure.root, file),
+          suggestion: `Add schema: .ToTable("${tableName}", SchemaConstants.Core)`
+        });
+      }
+    }
+  }
+}
+async function validateMigrationNaming(structure, _config, result) {
+  if (!structure.migrations) {
+    result.warnings.push({
+      type: "warning",
+      category: "migrations",
+      message: "Migrations folder not found, skipping migration validation"
+    });
+    return;
+  }
+  const migrationFiles = await findFiles("*.cs", { cwd: structure.migrations });
+  const migrationPattern = /^(\d{8})_(\d{3})_(.+)\.cs$/;
+  const designerPattern = /\.Designer\.cs$/;
+  for (const file of migrationFiles) {
+    const fileName = path5.basename(file);
+    if (designerPattern.test(fileName) || fileName.includes("ModelSnapshot")) {
+      continue;
+    }
+    if (!migrationPattern.test(fileName)) {
+      result.errors.push({
+        type: "error",
+        category: "migrations",
+        message: `Migration "${fileName}" does not follow naming convention`,
+        file: path5.relative(structure.root, file),
+        suggestion: `Expected format: YYYYMMDD_NNN_Description.cs (e.g., 20260115_001_InitialCreate.cs)`
+      });
+    }
+  }
+  const orderedMigrations = migrationFiles.map((f) => path5.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];
+    const prevDate = prev.substring(0, 8);
+    const currDate = curr.substring(0, 8);
+    if (currDate < prevDate) {
+      result.warnings.push({
+        type: "warning",
+        category: "migrations",
+        message: `Migration order issue: "${curr}" dated before "${prev}"`
+      });
+    }
+  }
+}
+async function validateServiceInterfaces(structure, config, result) {
+  if (!structure.application) {
+    result.warnings.push({
+      type: "warning",
+      category: "services",
+      message: "Application project not found, skipping service validation"
+    });
+    return;
+  }
+  const serviceFiles = await findFiles("**/*Service.cs", {
+    cwd: structure.application
+  });
+  for (const file of serviceFiles) {
+    const content = await readText(file);
+    const fileName = path5.basename(file, ".cs");
+    if (fileName.startsWith("I")) continue;
+    const expectedInterface = `I${fileName}`;
+    const interfacePattern = new RegExp(`:\\s*${expectedInterface}\\b`);
+    if (!interfacePattern.test(content)) {
+      const declaresInterface = content.includes(`interface ${expectedInterface}`);
+      if (!declaresInterface) {
+        result.warnings.push({
+          type: "warning",
+          category: "services",
+          message: `Service "${fileName}" should implement "${expectedInterface}"`,
+          file: path5.relative(structure.root, file),
+          suggestion: `Create interface ${expectedInterface} and implement it`
+        });
+      }
+    }
+  }
+}
+async function validateNamespaces(structure, config, result) {
+  const layers = [
+    { path: structure.domain, expected: config.conventions.namespaces.domain, name: "Domain" },
+    { path: structure.application, expected: config.conventions.namespaces.application, name: "Application" },
+    { path: structure.infrastructure, expected: config.conventions.namespaces.infrastructure, name: "Infrastructure" },
+    { path: structure.api, expected: config.conventions.namespaces.api, name: "Api" }
+  ];
+  for (const layer of layers) {
+    if (!layer.path) continue;
+    const csFiles = await findFiles("**/*.cs", { cwd: layer.path });
+    for (const file of csFiles.slice(0, 10)) {
+      const content = await readText(file);
+      const namespaceMatch = content.match(/namespace\s+([\w.]+)/);
+      if (namespaceMatch) {
+        const namespace = namespaceMatch[1];
+        if (!namespace.startsWith(layer.expected)) {
+          result.errors.push({
+            type: "error",
+            category: "namespaces",
+            message: `${layer.name} file has incorrect namespace "${namespace}"`,
+            file: path5.relative(structure.root, file),
+            suggestion: `Should start with "${layer.expected}"`
+          });
+        }
+      }
+    }
+  }
+}
+function generateSummary(result, checks) {
+  const parts = [];
+  parts.push(`Checks performed: ${checks.join(", ")}`);
+  parts.push(`Errors: ${result.errors.length}`);
+  parts.push(`Warnings: ${result.warnings.length}`);
+  parts.push(`Status: ${result.valid ? "PASSED" : "FAILED"}`);
+  return parts.join(" | ");
+}
+function formatResult(result) {
+  const lines = [];
+  lines.push("# Conventions Validation Report");
+  lines.push("");
+  lines.push(`## Summary`);
+  lines.push(`- **Status**: ${result.valid ? "\u2705 PASSED" : "\u274C FAILED"}`);
+  lines.push(`- **Errors**: ${result.errors.length}`);
+  lines.push(`- **Warnings**: ${result.warnings.length}`);
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push("## Errors");
+    lines.push("");
+    for (const error of result.errors) {
+      lines.push(`### \u274C ${error.category}: ${error.message}`);
+      if (error.file) lines.push(`- **File**: \`${error.file}\``);
+      if (error.line) lines.push(`- **Line**: ${error.line}`);
+      if (error.suggestion) lines.push(`- **Suggestion**: ${error.suggestion}`);
+      lines.push("");
+    }
+  }
+  if (result.warnings.length > 0) {
+    lines.push("## Warnings");
+    lines.push("");
+    for (const warning of result.warnings) {
+      lines.push(`### \u26A0\uFE0F ${warning.category}: ${warning.message}`);
+      if (warning.file) lines.push(`- **File**: \`${warning.file}\``);
+      if (warning.suggestion) lines.push(`- **Suggestion**: ${warning.suggestion}`);
+      lines.push("");
+    }
+  }
+  if (result.errors.length === 0 && result.warnings.length === 0) {
+    lines.push("## Result");
+    lines.push("");
+    lines.push("All conventions validated successfully! \u2728");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/check-migrations.ts
+import path6 from "path";
+var checkMigrationsTool = {
+  name: "check_migrations",
+  description: "Analyze EF Core migrations for conflicts, ordering issues, and ModelSnapshot discrepancies between branches",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectPath: {
+        type: "string",
+        description: "EF Core project path (default: auto-detect from config)"
+      },
+      branch: {
+        type: "string",
+        description: "Git branch to check (default: current branch)"
+      },
+      compareBranch: {
+        type: "string",
+        description: 'Branch to compare against (e.g., "develop")'
+      }
+    }
+  }
+};
+async function handleCheckMigrations(args, config) {
+  const input = CheckMigrationsInputSchema.parse(args);
+  const projectPath = input.projectPath || config.smartstack.projectPath;
+  logger.info("Checking migrations", { projectPath, branch: input.branch });
+  const structure = await findSmartStackStructure(projectPath);
+  if (!structure.migrations) {
+    return "# Migration Check\n\n\u274C No migrations folder found in the project.";
+  }
+  const result = {
+    hasConflicts: false,
+    migrations: [],
+    conflicts: [],
+    suggestions: []
+  };
+  const currentBranch = input.branch || await getCurrentBranch(projectPath) || "unknown";
+  result.migrations = await parseMigrations(structure.migrations, structure.root);
+  checkNamingConventions(result, config);
+  checkChronologicalOrder(result);
+  if (input.compareBranch && await branchExists(input.compareBranch, projectPath)) {
+    await checkBranchConflicts(
+      result,
+      structure,
+      currentBranch,
+      input.compareBranch,
+      projectPath
+    );
+  }
+  await checkModelSnapshot(result, structure);
+  result.hasConflicts = result.conflicts.length > 0;
+  generateSuggestions(result);
+  return formatResult2(result, currentBranch, input.compareBranch);
+}
+async function parseMigrations(migrationsPath, rootPath) {
+  const files = await findFiles("*.cs", { cwd: migrationsPath });
+  const migrations = [];
+  const pattern = /^(\d{8})_(\d{3})_(.+)\.cs$/;
+  for (const file of files) {
+    const fileName = path6.basename(file);
+    if (fileName.includes(".Designer.") || fileName.includes("ModelSnapshot")) {
+      continue;
+    }
+    const match = pattern.exec(fileName);
+    if (match) {
+      migrations.push({
+        name: fileName.replace(".cs", ""),
+        timestamp: match[1],
+        prefix: match[2],
+        // Now this is the sequence number (NNN)
+        description: match[3],
+        file: path6.relative(rootPath, file),
+        applied: true
+        // We'd need DB connection to check this
+      });
+    } else {
+      migrations.push({
+        name: fileName.replace(".cs", ""),
+        timestamp: "",
+        prefix: "Unknown",
+        description: fileName.replace(".cs", ""),
+        file: path6.relative(rootPath, file),
+        applied: true
+      });
+    }
+  }
+  return migrations.sort((a, b) => {
+    const dateCompare = a.timestamp.localeCompare(b.timestamp);
+    if (dateCompare !== 0) return dateCompare;
+    return a.prefix.localeCompare(b.prefix);
+  });
+}
+function checkNamingConventions(result, _config) {
+  for (const migration of result.migrations) {
+    if (!migration.timestamp) {
+      result.conflicts.push({
+        type: "naming",
+        description: `Migration "${migration.name}" does not follow naming convention`,
+        files: [migration.file],
+        resolution: `Rename to format: YYYYMMDD_NNN_Description (e.g., 20260115_001_InitialCreate)`
+      });
+    }
+    if (migration.prefix === "Unknown") {
+      result.conflicts.push({
+        type: "naming",
+        description: `Migration "${migration.name}" missing sequence number`,
+        files: [migration.file],
+        resolution: `Use format: YYYYMMDD_NNN_Description where NNN is a 3-digit sequence (001, 002, etc.)`
+      });
+    }
+  }
+}
+function checkChronologicalOrder(result) {
+  const migrations = result.migrations.filter((m) => m.timestamp);
+  for (let i = 1; i < migrations.length; i++) {
+    const prev = migrations[i - 1];
+    const curr = migrations[i];
+    if (curr.timestamp < prev.timestamp) {
+      result.conflicts.push({
+        type: "order",
+        description: `Migration "${curr.name}" (${curr.timestamp}) is dated before "${prev.name}" (${prev.timestamp})`,
+        files: [curr.file, prev.file],
+        resolution: "Reorder migrations or update timestamps"
+      });
+    }
+    if (curr.timestamp === prev.timestamp && curr.prefix === prev.prefix) {
+      result.conflicts.push({
+        type: "order",
+        description: `Migrations "${curr.name}" and "${prev.name}" have same timestamp`,
+        files: [curr.file, prev.file],
+        resolution: "Use different sequence numbers (NNN) or different dates"
+      });
+    }
+  }
+}
+async function checkBranchConflicts(result, structure, currentBranch, compareBranch, projectPath) {
+  if (!structure.migrations) return;
+  const migrationsRelPath = path6.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 currentSnapshot = await readText(snapshotFiles[0]);
+    const compareSnapshot = await getFileFromBranch(compareBranch, snapshotRelPath, projectPath);
+    if (compareSnapshot && currentSnapshot !== compareSnapshot) {
+      const diff = await getDiff(compareBranch, currentBranch, snapshotRelPath, projectPath);
+      if (diff) {
+        result.conflicts.push({
+          type: "snapshot",
+          description: `ModelSnapshot differs between "${currentBranch}" and "${compareBranch}"`,
+          files: [snapshotRelPath],
+          resolution: "Rebase on target branch and regenerate migrations with: dotnet ef migrations add <Name>"
+        });
+      }
+    }
+  }
+  const compareMigrations = await getFileFromBranch(
+    compareBranch,
+    migrationsRelPath,
+    projectPath
+  );
+  if (compareMigrations) {
+    logger.debug("Branch comparison completed", { compareBranch });
+  }
+}
+async function checkModelSnapshot(result, structure) {
+  if (!structure.migrations) return;
+  const snapshotFiles = await findFiles("*ModelSnapshot.cs", { cwd: structure.migrations });
+  if (snapshotFiles.length === 0) {
+    result.conflicts.push({
+      type: "snapshot",
+      description: "No ModelSnapshot file found",
+      files: [],
+      resolution: "Run: dotnet ef migrations add InitialCreate"
+    });
+    return;
+  }
+  if (snapshotFiles.length > 1) {
+    result.conflicts.push({
+      type: "snapshot",
+      description: "Multiple ModelSnapshot files found",
+      files: snapshotFiles.map((f) => path6.relative(structure.root, f)),
+      resolution: "Remove duplicate snapshots, keep only one per DbContext"
+    });
+  }
+  const snapshotContent = await readText(snapshotFiles[0]);
+  for (const migration of result.migrations) {
+    if (migration.timestamp && !snapshotContent.includes(migration.name)) {
+      result.conflicts.push({
+        type: "dependency",
+        description: `Migration "${migration.name}" not referenced in ModelSnapshot`,
+        files: [migration.file],
+        resolution: "Migration may not be applied. Run: dotnet ef database update"
+      });
+    }
+  }
+}
+function generateSuggestions(result) {
+  if (result.conflicts.some((c) => c.type === "snapshot")) {
+    result.suggestions.push(
+      "Consider rebasing on the target branch before merging to avoid snapshot conflicts"
+    );
+  }
+  if (result.conflicts.some((c) => c.type === "naming")) {
+    result.suggestions.push(
+      "Use convention: YYYYMMDD_NNN_Description for migration naming (e.g., 20260115_001_InitialCreate)"
+    );
+  }
+  if (result.conflicts.some((c) => c.type === "order")) {
+    result.suggestions.push(
+      "Ensure migrations are created in chronological order to avoid conflicts"
+    );
+  }
+  if (result.migrations.length > 20) {
+    result.suggestions.push(
+      "Consider squashing old migrations to reduce complexity. Use: /efcore squash"
+    );
+  }
+}
+function formatResult2(result, currentBranch, compareBranch) {
+  const lines = [];
+  lines.push("# EF Core Migration Check Report");
+  lines.push("");
+  lines.push("## Overview");
+  lines.push(`- **Current Branch**: ${currentBranch}`);
+  if (compareBranch) {
+    lines.push(`- **Compare Branch**: ${compareBranch}`);
+  }
+  lines.push(`- **Total Migrations**: ${result.migrations.length}`);
+  lines.push(`- **Conflicts Found**: ${result.conflicts.length}`);
+  lines.push(`- **Status**: ${result.hasConflicts ? "\u274C CONFLICTS DETECTED" : "\u2705 OK"}`);
+  lines.push("");
+  lines.push("## Migrations");
+  lines.push("");
+  lines.push("| Name | Timestamp | Prefix | Description |");
+  lines.push("|------|-----------|--------|-------------|");
+  for (const migration of result.migrations) {
+    lines.push(
+      `| ${migration.name} | ${migration.timestamp || "N/A"} | ${migration.prefix} | ${migration.description} |`
+    );
+  }
+  lines.push("");
+  if (result.conflicts.length > 0) {
+    lines.push("## Conflicts");
+    lines.push("");
+    for (const conflict of result.conflicts) {
+      const icon = conflict.type === "snapshot" ? "\u{1F504}" : conflict.type === "order" ? "\u{1F4C5}" : conflict.type === "naming" ? "\u{1F4DD}" : "\u26A0\uFE0F";
+      lines.push(`### ${icon} ${conflict.type.toUpperCase()}: ${conflict.description}`);
+      if (conflict.files.length > 0) {
+        lines.push(`- **Files**: ${conflict.files.map((f) => `\`${f}\``).join(", ")}`);
+      }
+      lines.push(`- **Resolution**: ${conflict.resolution}`);
+      lines.push("");
+    }
+  }
+  if (result.suggestions.length > 0) {
+    lines.push("## Suggestions");
+    lines.push("");
+    for (const suggestion of result.suggestions) {
+      lines.push(`- \u{1F4A1} ${suggestion}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/scaffold-extension.ts
+import Handlebars from "handlebars";
+import path7 from "path";
+var scaffoldExtensionTool = {
+  name: "scaffold_extension",
+  description: "Generate code to extend SmartStack: service (interface + implementation), entity (class + EF config), controller (REST endpoints), or React component",
+  inputSchema: {
+    type: "object",
+    properties: {
+      type: {
+        type: "string",
+        enum: ["service", "entity", "controller", "component"],
+        description: "Type of extension to scaffold"
+      },
+      name: {
+        type: "string",
+        description: 'Name of the extension (e.g., "UserProfile", "Order")'
+      },
+      options: {
+        type: "object",
+        properties: {
+          namespace: {
+            type: "string",
+            description: "Custom namespace (optional)"
+          },
+          baseEntity: {
+            type: "string",
+            description: "Base entity to extend (for entity type)"
+          },
+          methods: {
+            type: "array",
+            items: { type: "string" },
+            description: "Methods to generate (for service type)"
+          },
+          outputPath: {
+            type: "string",
+            description: "Custom output path"
+          }
+        }
+      }
+    },
+    required: ["type", "name"]
+  }
+};
+Handlebars.registerHelper("pascalCase", (str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+Handlebars.registerHelper("camelCase", (str) => {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+});
+Handlebars.registerHelper("kebabCase", (str) => {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+});
+async function handleScaffoldExtension(args, config) {
+  const input = ScaffoldExtensionInputSchema.parse(args);
+  logger.info("Scaffolding extension", { type: input.type, name: input.name });
+  const structure = await findSmartStackStructure(config.smartstack.projectPath);
+  const result = {
+    success: true,
+    files: [],
+    instructions: []
+  };
+  try {
+    switch (input.type) {
+      case "service":
+        await scaffoldService(input.name, input.options, structure, config, result);
+        break;
+      case "entity":
+        await scaffoldEntity(input.name, input.options, structure, config, result);
+        break;
+      case "controller":
+        await scaffoldController(input.name, input.options, structure, config, result);
+        break;
+      case "component":
+        await scaffoldComponent(input.name, input.options, structure, config, result);
+        break;
+    }
+  } catch (error) {
+    result.success = false;
+    result.instructions.push(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  return formatResult3(result, input.type, input.name);
+}
+async function scaffoldService(name, options, structure, config, result) {
+  const namespace = options?.namespace || `${config.conventions.namespaces.application}.Services`;
+  const methods = options?.methods || ["GetByIdAsync", "GetAllAsync", "CreateAsync", "UpdateAsync", "DeleteAsync"];
+  const interfaceTemplate = `using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+namespace {{namespace}};
+
+/// <summary>
+/// Service interface for {{name}} operations
+/// </summary>
+public interface I{{name}}Service
+{
+{{#each methods}}
+    /// <summary>
+    /// {{this}} operation
+    /// </summary>
+    Task<object> {{this}}(CancellationToken cancellationToken = default);
+
+{{/each}}
+}
+`;
+  const implementationTemplate = `using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+
+namespace {{namespace}};
+
+/// <summary>
+/// Service implementation for {{name}} operations
+/// </summary>
+public class {{name}}Service : I{{name}}Service
+{
+    private readonly ILogger<{{name}}Service> _logger;
+
+    public {{name}}Service(ILogger<{{name}}Service> logger)
+    {
+        _logger = logger;
+    }
+
+{{#each methods}}
+    /// <inheritdoc />
+    public async Task<object> {{this}}(CancellationToken cancellationToken = default)
+    {
+        _logger.LogInformation("Executing {{this}}");
+        // TODO: Implement {{this}}
+        await Task.CompletedTask;
+        throw new NotImplementedException();
+    }
+
+{{/each}}
+}
+`;
+  const diTemplate = `// Add to DependencyInjection.cs or ServiceCollectionExtensions.cs:
+services.AddScoped<I{{name}}Service, {{name}}Service>();
+`;
+  const context = { namespace, name, methods };
+  const interfaceContent = Handlebars.compile(interfaceTemplate)(context);
+  const implementationContent = Handlebars.compile(implementationTemplate)(context);
+  const diContent = Handlebars.compile(diTemplate)(context);
+  const basePath = structure.application || config.smartstack.projectPath;
+  const servicesPath = path7.join(basePath, "Services");
+  await ensureDirectory(servicesPath);
+  const interfacePath = path7.join(servicesPath, `I${name}Service.cs`);
+  const implementationPath = path7.join(servicesPath, `${name}Service.cs`);
+  await writeText(interfacePath, interfaceContent);
+  result.files.push({ path: interfacePath, content: interfaceContent, type: "created" });
+  await writeText(implementationPath, implementationContent);
+  result.files.push({ path: implementationPath, content: implementationContent, type: "created" });
+  result.instructions.push("Register service in DI container:");
+  result.instructions.push(diContent);
+}
+async function scaffoldEntity(name, options, structure, config, result) {
+  const namespace = options?.namespace || config.conventions.namespaces.domain;
+  const baseEntity = options?.baseEntity;
+  const entityTemplate = `using System;
+
+namespace {{namespace}};
+
+/// <summary>
+/// {{name}} entity{{#if baseEntity}} extending {{baseEntity}}{{/if}}
+/// </summary>
+public class {{name}}{{#if baseEntity}} : {{baseEntity}}{{/if}}
+{
+{{#unless baseEntity}}
+    public Guid Id { get; set; }
+
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+    public DateTime? UpdatedAt { get; set; }
+
+{{/unless}}
+    // TODO: Add {{name}} specific properties
+}
+`;
+  const configTemplate = `using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace {{infrastructureNamespace}}.Persistence.Configurations;
+
+public class {{name}}Configuration : IEntityTypeConfiguration<{{domainNamespace}}.{{name}}>
+{
+    public void Configure(EntityTypeBuilder<{{domainNamespace}}.{{name}}> builder)
+    {
+        builder.ToTable("{{tablePrefix}}{{name}}s");
+
+        builder.HasKey(e => e.Id);
+
+        // TODO: Add {{name}} specific configuration
+    }
+}
+`;
+  const context = {
+    namespace,
+    name,
+    baseEntity,
+    infrastructureNamespace: config.conventions.namespaces.infrastructure,
+    domainNamespace: config.conventions.namespaces.domain,
+    tablePrefix: config.conventions.tablePrefix.core
+  };
+  const entityContent = Handlebars.compile(entityTemplate)(context);
+  const configContent = Handlebars.compile(configTemplate)(context);
+  const domainPath = structure.domain || path7.join(config.smartstack.projectPath, "Domain");
+  const infraPath = structure.infrastructure || path7.join(config.smartstack.projectPath, "Infrastructure");
+  await ensureDirectory(domainPath);
+  await ensureDirectory(path7.join(infraPath, "Persistence", "Configurations"));
+  const entityFilePath = path7.join(domainPath, `${name}.cs`);
+  const configFilePath = path7.join(infraPath, "Persistence", "Configurations", `${name}Configuration.cs`);
+  await writeText(entityFilePath, entityContent);
+  result.files.push({ path: entityFilePath, content: entityContent, type: "created" });
+  await writeText(configFilePath, configContent);
+  result.files.push({ path: configFilePath, content: configContent, type: "created" });
+  result.instructions.push(`Add DbSet to ApplicationDbContext:`);
+  result.instructions.push(`public DbSet<${name}> ${name}s => Set<${name}>();`);
+  result.instructions.push("");
+  result.instructions.push("Create migration:");
+  result.instructions.push(`dotnet ef migrations add Add${name}`);
+}
+async function scaffoldController(name, options, structure, config, result) {
+  const namespace = options?.namespace || `${config.conventions.namespaces.api}.Controllers`;
+  const controllerTemplate = `using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace {{namespace}};
+
+/// <summary>
+/// API controller for {{name}} operations
+/// </summary>
+[ApiController]
+[Route("api/[controller]")]
+[Authorize]
+public class {{name}}Controller : ControllerBase
+{
+    private readonly ILogger<{{name}}Controller> _logger;
+
+    public {{name}}Controller(ILogger<{{name}}Controller> logger)
+    {
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Get all {{nameLower}}s
+    /// </summary>
+    [HttpGet]
+    public async Task<ActionResult<IEnumerable<{{name}}Dto>>> GetAll()
+    {
+        _logger.LogInformation("Getting all {{nameLower}}s");
+        // TODO: Implement
+        return Ok(Array.Empty<{{name}}Dto>());
+    }
+
+    /// <summary>
+    /// Get {{nameLower}} by ID
+    /// </summary>
+    [HttpGet("{id:guid}")]
+    public async Task<ActionResult<{{name}}Dto>> GetById(Guid id)
+    {
+        _logger.LogInformation("Getting {{nameLower}} {Id}", id);
+        // TODO: Implement
+        return NotFound();
+    }
+
+    /// <summary>
+    /// Create new {{nameLower}}
+    /// </summary>
+    [HttpPost]
+    public async Task<ActionResult<{{name}}Dto>> Create([FromBody] Create{{name}}Request request)
+    {
+        _logger.LogInformation("Creating {{nameLower}}");
+        // TODO: Implement
+        return CreatedAtAction(nameof(GetById), new { id = Guid.NewGuid() }, null);
+    }
+
+    /// <summary>
+    /// Update {{nameLower}}
+    /// </summary>
+    [HttpPut("{id:guid}")]
+    public async Task<ActionResult> Update(Guid id, [FromBody] Update{{name}}Request request)
+    {
+        _logger.LogInformation("Updating {{nameLower}} {Id}", id);
+        // TODO: Implement
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Delete {{nameLower}}
+    /// </summary>
+    [HttpDelete("{id:guid}")]
+    public async Task<ActionResult> Delete(Guid id)
+    {
+        _logger.LogInformation("Deleting {{nameLower}} {Id}", id);
+        // TODO: Implement
+        return NoContent();
+    }
+}
+
+// DTOs
+public record {{name}}Dto(Guid Id, DateTime CreatedAt);
+public record Create{{name}}Request();
+public record Update{{name}}Request();
+`;
+  const context = {
+    namespace,
+    name,
+    nameLower: name.charAt(0).toLowerCase() + name.slice(1)
+  };
+  const controllerContent = Handlebars.compile(controllerTemplate)(context);
+  const apiPath = structure.api || path7.join(config.smartstack.projectPath, "Api");
+  const controllersPath = path7.join(apiPath, "Controllers");
+  await ensureDirectory(controllersPath);
+  const controllerFilePath = path7.join(controllersPath, `${name}Controller.cs`);
+  await writeText(controllerFilePath, controllerContent);
+  result.files.push({ path: controllerFilePath, content: controllerContent, type: "created" });
+  result.instructions.push("Controller created. API endpoints:");
+  result.instructions.push(`  GET    /api/${name.toLowerCase()}`);
+  result.instructions.push(`  GET    /api/${name.toLowerCase()}/{id}`);
+  result.instructions.push(`  POST   /api/${name.toLowerCase()}`);
+  result.instructions.push(`  PUT    /api/${name.toLowerCase()}/{id}`);
+  result.instructions.push(`  DELETE /api/${name.toLowerCase()}/{id}`);
+}
+async function scaffoldComponent(name, options, structure, config, result) {
+  const componentTemplate = `import React, { useState, useEffect } from 'react';
+
+interface {{name}}Props {
+  id?: string;
+  onSave?: (data: {{name}}Data) => void;
+  onCancel?: () => void;
+}
+
+interface {{name}}Data {
+  id?: string;
+  // TODO: Add {{name}} data properties
+}
+
+/**
+ * {{name}} component
+ */
+export const {{name}}: React.FC<{{name}}Props> = ({ id, onSave, onCancel }) => {
+  const [data, setData] = useState<{{name}}Data | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (id) {
+      // TODO: Fetch {{nameLower}} data
+      setLoading(true);
+      // fetch...
+      setLoading(false);
+    }
+  }, [id]);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (data && onSave) {
+      onSave(data);
+    }
+  };
+
+  if (loading) {
+    return <div className="animate-pulse">Loading...</div>;
+  }
+
+  if (error) {
+    return <div className="text-red-500">{error}</div>;
+  }
+
+  return (
+    <div className="p-4">
+      <h2 className="text-xl font-semibold mb-4">{{name}}</h2>
+      <form onSubmit={handleSubmit} className="space-y-4">
+        {/* TODO: Add form fields */}
+        <div className="flex gap-2">
+          <button
+            type="submit"
+            className="px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600"
+          >
+            Save
+          </button>
+          {onCancel && (
+            <button
+              type="button"
+              onClick={onCancel}
+              className="px-4 py-2 bg-gray-200 rounded hover:bg-gray-300"
+            >
+              Cancel
+            </button>
+          )}
+        </div>
+      </form>
+    </div>
+  );
+};
+
+export default {{name}};
+`;
+  const hookTemplate = `import { useState, useEffect, useCallback } from 'react';
+import { {{nameLower}}Api } from '../services/api/{{nameLower}}';
+
+interface {{name}}Data {
+  id?: string;
+  // TODO: Add properties
+}
+
+interface Use{{name}}Options {
+  id?: string;
+  autoFetch?: boolean;
+}
+
+export function use{{name}}(options: Use{{name}}Options = {}) {
+  const { id, autoFetch = true } = options;
+  const [data, setData] = useState<{{name}}Data | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetch{{name}} = useCallback(async (fetchId?: string) => {
+    const targetId = fetchId || id;
+    if (!targetId) return;
+
+    setLoading(true);
+    setError(null);
+    try {
+      // TODO: Implement API call
+      // const result = await {{nameLower}}Api.getById(targetId);
+      // setData(result);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error('Unknown error'));
+    } finally {
+      setLoading(false);
+    }
+  }, [id]);
+
+  const save{{name}} = useCallback(async (saveData: {{name}}Data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      // TODO: Implement API call
+      // const result = saveData.id
+      //   ? await {{nameLower}}Api.update(saveData.id, saveData)
+      //   : await {{nameLower}}Api.create(saveData);
+      // setData(result);
+      // return result;
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error('Unknown error'));
+      throw e;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (autoFetch && id) {
+      fetch{{name}}();
+    }
+  }, [autoFetch, id, fetch{{name}}]);
+
+  return {
+    data,
+    loading,
+    error,
+    fetch: fetch{{name}},
+    save: save{{name}},
+    setData,
+  };
+}
+`;
+  const context = {
+    name,
+    nameLower: name.charAt(0).toLowerCase() + name.slice(1)
+  };
+  const componentContent = Handlebars.compile(componentTemplate)(context);
+  const hookContent = Handlebars.compile(hookTemplate)(context);
+  const webPath = structure.web || path7.join(config.smartstack.projectPath, "web", "smartstack-web");
+  const componentsPath = options?.outputPath || path7.join(webPath, "src", "components");
+  const hooksPath = path7.join(webPath, "src", "hooks");
+  await ensureDirectory(componentsPath);
+  await ensureDirectory(hooksPath);
+  const componentFilePath = path7.join(componentsPath, `${name}.tsx`);
+  const hookFilePath = path7.join(hooksPath, `use${name}.ts`);
+  await writeText(componentFilePath, componentContent);
+  result.files.push({ path: componentFilePath, content: componentContent, type: "created" });
+  await writeText(hookFilePath, hookContent);
+  result.files.push({ path: hookFilePath, content: hookContent, type: "created" });
+  result.instructions.push("Import and use the component:");
+  result.instructions.push(`import { ${name} } from './components/${name}';`);
+  result.instructions.push(`import { use${name} } from './hooks/use${name}';`);
+}
+function formatResult3(result, type, name) {
+  const lines = [];
+  lines.push(`# Scaffold ${type}: ${name}`);
+  lines.push("");
+  if (result.success) {
+    lines.push("## \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(`**Path**: \`${file.path}\``);
+      lines.push("");
+      lines.push("```" + (file.path.endsWith(".cs") ? "csharp" : "typescript"));
+      const contentLines = file.content.split("\n").slice(0, 50);
+      lines.push(contentLines.join("\n"));
+      if (file.content.split("\n").length > 50) {
+        lines.push("// ... (truncated)");
+      }
+      lines.push("```");
+      lines.push("");
+    }
+    if (result.instructions.length > 0) {
+      lines.push("## \u{1F4CB} Next Steps");
+      lines.push("");
+      for (const instruction of result.instructions) {
+        if (instruction.startsWith("services.") || instruction.startsWith("public DbSet")) {
+          lines.push("```csharp");
+          lines.push(instruction);
+          lines.push("```");
+        } else if (instruction.startsWith("dotnet ")) {
+          lines.push("```bash");
+          lines.push(instruction);
+          lines.push("```");
+        } else if (instruction.startsWith("import ")) {
+          lines.push("```typescript");
+          lines.push(instruction);
+          lines.push("```");
+        } else {
+          lines.push(instruction);
+        }
+      }
+    }
+  } else {
+    lines.push("## \u274C Generation Failed");
+    lines.push("");
+    for (const instruction of result.instructions) {
+      lines.push(`- ${instruction}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/tools/api-docs.ts
+import axios from "axios";
+import path8 from "path";
+var apiDocsTool = {
+  name: "api_docs",
+  description: "Get API documentation for SmartStack endpoints. Can fetch from Swagger/OpenAPI or parse controller files directly.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      endpoint: {
+        type: "string",
+        description: 'Filter by endpoint path (e.g., "/api/users"). Leave empty for all endpoints.'
+      },
+      format: {
+        type: "string",
+        enum: ["markdown", "json", "openapi"],
+        description: "Output format",
+        default: "markdown"
+      },
+      controller: {
+        type: "string",
+        description: 'Filter by controller name (e.g., "Users")'
+      }
+    }
+  }
+};
+async function handleApiDocs(args, config) {
+  const input = ApiDocsInputSchema.parse(args);
+  logger.info("Fetching API documentation", { endpoint: input.endpoint, format: input.format });
+  let endpoints = [];
+  if (config.smartstack.apiEnabled && config.smartstack.apiUrl) {
+    try {
+      endpoints = await fetchFromSwagger(config.smartstack.apiUrl);
+      logger.debug("Fetched endpoints from Swagger", { count: endpoints.length });
+    } catch (error) {
+      logger.warn("Failed to fetch from Swagger, falling back to code parsing", { error });
+    }
+  }
+  if (endpoints.length === 0) {
+    const structure = await findSmartStackStructure(config.smartstack.projectPath);
+    endpoints = await parseControllers(structure);
+  }
+  if (input.endpoint) {
+    const filter = input.endpoint.toLowerCase();
+    endpoints = endpoints.filter((e) => e.path.toLowerCase().includes(filter));
+  }
+  if (input.controller) {
+    const filter = input.controller.toLowerCase();
+    endpoints = endpoints.filter((e) => e.controller.toLowerCase().includes(filter));
+  }
+  switch (input.format) {
+    case "json":
+      return JSON.stringify(endpoints, null, 2);
+    case "openapi":
+      return formatAsOpenApi(endpoints);
+    case "markdown":
+    default:
+      return formatAsMarkdown(endpoints);
+  }
+}
+async function fetchFromSwagger(apiUrl) {
+  const swaggerUrl = `${apiUrl}/swagger/v1/swagger.json`;
+  const response = await axios.get(swaggerUrl, {
+    timeout: 5e3,
+    httpsAgent: new (await import("https")).Agent({ rejectUnauthorized: false })
+  });
+  const spec = response.data;
+  const endpoints = [];
+  for (const [pathKey, pathItem] of Object.entries(spec.paths || {})) {
+    const pathObj = pathItem;
+    for (const method of ["get", "post", "put", "patch", "delete"]) {
+      const operation = pathObj[method];
+      if (!operation) continue;
+      const tags = operation.tags || ["Unknown"];
+      const parameters = operation.parameters || [];
+      endpoints.push({
+        method: method.toUpperCase(),
+        path: pathKey,
+        controller: tags[0],
+        action: operation.operationId || method,
+        summary: operation.summary,
+        parameters: parameters.map((p) => ({
+          name: p.name,
+          in: p.in,
+          type: p.schema?.type || "string",
+          required: p.required || false,
+          description: p.description
+        })),
+        requestBody: operation.requestBody ? "See schema" : void 0,
+        responses: Object.entries(operation.responses || {}).map(([status, resp]) => ({
+          status: parseInt(status, 10),
+          description: resp.description
+        })),
+        authorize: !!(operation.security && operation.security.length > 0)
+      });
+    }
+  }
+  return endpoints;
+}
+async function parseControllers(structure) {
+  if (!structure.api) {
+    return [];
+  }
+  const controllerFiles = await findControllerFiles(structure.api);
+  const endpoints = [];
+  for (const file of controllerFiles) {
+    const content = await readText(file);
+    const fileName = path8.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()}`;
+    const hasAuthorize = content.includes("[Authorize]");
+    const httpMethods = [
+      { pattern: /\[HttpGet(?:\s*\(\s*"([^"]*)"\s*\))?\]/g, method: "GET" },
+      { pattern: /\[HttpPost(?:\s*\(\s*"([^"]*)"\s*\))?\]/g, method: "POST" },
+      { pattern: /\[HttpPut(?:\s*\(\s*"([^"]*)"\s*\))?\]/g, method: "PUT" },
+      { pattern: /\[HttpPatch(?:\s*\(\s*"([^"]*)"\s*\))?\]/g, method: "PATCH" },
+      { pattern: /\[HttpDelete(?:\s*\(\s*"([^"]*)"\s*\))?\]/g, method: "DELETE" }
+    ];
+    for (const { pattern, method } of httpMethods) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const routeSuffix = match[1] || "";
+        const fullPath = routeSuffix ? `${baseRoute}/${routeSuffix}` : baseRoute;
+        const afterAttribute = content.substring(match.index);
+        const methodMatch = afterAttribute.match(/public\s+(?:async\s+)?(?:Task<)?(?:ActionResult<)?(\w+)(?:>)?\s+(\w+)\s*\(/);
+        const parameters = [];
+        const pathParams = fullPath.match(/\{(\w+)(?::\w+)?\}/g);
+        if (pathParams) {
+          for (const param of pathParams) {
+            const paramName = param.replace(/[{}:]/g, "").replace(/\w+$/, "");
+            parameters.push({
+              name: paramName || param.replace(/[{}]/g, "").split(":")[0],
+              in: "path",
+              type: "string",
+              required: true
+            });
+          }
+        }
+        if (afterAttribute.includes("[FromBody]")) {
+          const bodyMatch = afterAttribute.match(/\[FromBody\]\s*(\w+)\s+(\w+)/);
+          if (bodyMatch) {
+            parameters.push({
+              name: bodyMatch[2],
+              in: "body",
+              type: bodyMatch[1],
+              required: true
+            });
+          }
+        }
+        const queryMatches = afterAttribute.matchAll(/\[FromQuery\]\s*(\w+)\s+(\w+)/g);
+        for (const qm of queryMatches) {
+          parameters.push({
+            name: qm[2],
+            in: "query",
+            type: qm[1],
+            required: false
+          });
+        }
+        endpoints.push({
+          method,
+          path: fullPath.replace(/\/+/g, "/"),
+          controller: controllerName,
+          action: methodMatch ? methodMatch[2] : "Unknown",
+          parameters,
+          responses: [{ status: 200, description: "Success" }],
+          authorize: hasAuthorize
+        });
+      }
+    }
+  }
+  return endpoints;
+}
+function formatAsMarkdown(endpoints) {
+  const lines = [];
+  lines.push("# SmartStack API Documentation");
+  lines.push("");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  const byController = /* @__PURE__ */ new Map();
+  for (const endpoint of endpoints) {
+    const existing = byController.get(endpoint.controller) || [];
+    existing.push(endpoint);
+    byController.set(endpoint.controller, existing);
+  }
+  for (const [controller, controllerEndpoints] of byController) {
+    lines.push(`## ${controller}`);
+    lines.push("");
+    for (const endpoint of controllerEndpoints) {
+      const authBadge = endpoint.authorize ? " \u{1F512}" : "";
+      lines.push(`### \`${endpoint.method}\` ${endpoint.path}${authBadge}`);
+      lines.push("");
+      if (endpoint.summary) {
+        lines.push(endpoint.summary);
+        lines.push("");
+      }
+      if (endpoint.parameters.length > 0) {
+        lines.push("**Parameters:**");
+        lines.push("");
+        lines.push("| Name | In | Type | Required |");
+        lines.push("|------|-----|------|----------|");
+        for (const param of endpoint.parameters) {
+          lines.push(`| ${param.name} | ${param.in} | ${param.type} | ${param.required ? "Yes" : "No"} |`);
+        }
+        lines.push("");
+      }
+      if (endpoint.responses.length > 0) {
+        lines.push("**Responses:**");
+        lines.push("");
+        for (const resp of endpoint.responses) {
+          lines.push(`- \`${resp.status}\`: ${resp.description || "No description"}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  if (endpoints.length === 0) {
+    lines.push("No endpoints found matching the filter criteria.");
+  }
+  return lines.join("\n");
+}
+function formatAsOpenApi(endpoints) {
+  const spec = {
+    openapi: "3.0.0",
+    info: {
+      title: "SmartStack API",
+      version: "1.0.0"
+    },
+    paths: {}
+  };
+  for (const endpoint of endpoints) {
+    if (!spec.paths[endpoint.path]) {
+      spec.paths[endpoint.path] = {};
+    }
+    spec.paths[endpoint.path][endpoint.method.toLowerCase()] = {
+      tags: [endpoint.controller],
+      operationId: endpoint.action,
+      summary: endpoint.summary,
+      parameters: endpoint.parameters.filter((p) => p.in !== "body").map((p) => ({
+        name: p.name,
+        in: p.in,
+        required: p.required,
+        schema: { type: p.type }
+      })),
+      responses: Object.fromEntries(
+        endpoint.responses.map((r) => [
+          r.status.toString(),
+          { description: r.description || "Response" }
+        ])
+      ),
+      security: endpoint.authorize ? [{ bearerAuth: [] }] : void 0
+    };
+  }
+  return JSON.stringify(spec, null, 2);
+}
+
+// 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, 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 |
+| \`ai_\` | AI features | ai_Providers, ai_Models, ai_Prompts |
+| \`cfg_\` | Configuration | cfg_Settings |
+| \`wkf_\` | Workflows | wkf_EmailTemplates, wkf_Workflows |
+| \`support_\` | Support | support_Tickets, support_Comments |
+| \`entra_\` | Entra sync | entra_Groups, entra_SyncState |
+| \`ref_\` | References | ref_Companies, ref_Departments |
+| \`loc_\` | Localization | loc_Languages, loc_Translations |
+| \`lic_\` | Licensing | lic_Licenses |
+
+### Entity Configuration
+
+\`\`\`csharp
+public class MyEntityConfiguration : IEntityTypeConfiguration<MyEntity>
+{
+    public void Configure(EntityTypeBuilder<MyEntity> builder)
+    {
+        // CORRECT: Use schema + domain prefix
+        builder.ToTable("auth_Users", "${schemas.platform}");
+
+        // WRONG: No schema specified
+        // builder.ToTable("auth_Users");
+
+        // WRONG: No domain prefix
+        // builder.ToTable("Users", "${schemas.platform}");
+    }
+}
+\`\`\`
+
+### Extending Core Entities
+
+When extending a core entity, use the \`${schemas.extensions}\` schema:
+
+\`\`\`csharp
+// Client extension for auth_Users
+public class UserExtension
+{
+    public Guid UserId { get; set; }  // FK to auth_Users
+    public User User { get; set; }
+
+    // Custom properties
+    public string CustomField { get; set; }
+}
+
+// Configuration - use extensions schema
+builder.ToTable("client_UserExtensions", "${schemas.extensions}");
+builder.HasOne(e => e.User)
+       .WithOne()
+       .HasForeignKey<UserExtension>(e => e.UserId);
+\`\`\`
+
+---
+
+## 2. Migration Conventions
+
+### Naming Format
+
+Migrations MUST follow this naming pattern:
+
+\`\`\`
+${migrationFormat}
+\`\`\`
+
+**Examples:**
+- \`20260115_001_InitialSchema.cs\`
+- \`20260120_002_AddUserProfiles.cs\`
+- \`20260125_003_AddSupportTickets.cs\`
+
+### Creating Migrations
+
+\`\`\`bash
+# Create a new migration
+dotnet ef migrations add 20260115_001_InitialSchema
+
+# With context specified
+dotnet ef migrations add 20260115_001_InitialSchema --context ApplicationDbContext
+\`\`\`
+
+### Migration Rules
+
+1. **One migration per feature** - Group related changes in a single migration
+2. **Timestamps ensure order** - Use YYYYMMDD format for chronological sorting
+3. **Sequence numbers** - Use NNN (001, 002, etc.) for migrations on the same day
+4. **Descriptive names** - Use clear descriptions (InitialSchema, AddUserProfiles, etc.)
+5. **Schema must be specified** - All tables must specify their schema in ToTable()
+
+---
+
+## 3. Namespace Conventions
+
+### Layer Structure
+
+| Layer | Namespace | Purpose |
+|-------|-----------|---------|
+| Domain | \`${namespaces.domain}\` | Entities, value objects, domain events |
+| Application | \`${namespaces.application}\` | Use cases, services, interfaces |
+| Infrastructure | \`${namespaces.infrastructure}\` | EF Core, external services |
+| API | \`${namespaces.api}\` | Controllers, DTOs, middleware |
+
+### Example Namespaces
+
+\`\`\`csharp
+// Entity in Domain layer
+namespace ${namespaces.domain}.Entities;
+public class User { }
+
+// Service interface in Application layer
+namespace ${namespaces.application}.Services;
+public interface IUserService { }
+
+// EF Configuration in Infrastructure layer
+namespace ${namespaces.infrastructure}.Persistence.Configurations;
+public class UserConfiguration { }
+
+// Controller in API layer
+namespace ${namespaces.api}.Controllers;
+public class UsersController { }
+\`\`\`
+
+---
+
+## 4. Service Conventions
+
+### Naming Pattern
+
+| Type | Pattern | Example |
+|------|---------|---------|
+| Interface | \`${servicePattern.interface.replace("{Name}", "<Name>")}\` | \`IUserService\` |
+| Implementation | \`${servicePattern.implementation.replace("{Name}", "<Name>")}\` | \`UserService\` |
+
+### Service Structure
+
+\`\`\`csharp
+// Interface (in Application layer)
+namespace ${namespaces.application}.Services;
+
+public interface IUserService
+{
+    Task<UserDto> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<IEnumerable<UserDto>> GetAllAsync(CancellationToken ct = default);
+    Task<UserDto> CreateAsync(CreateUserCommand cmd, CancellationToken ct = default);
+    Task UpdateAsync(Guid id, UpdateUserCommand cmd, CancellationToken ct = default);
+    Task DeleteAsync(Guid id, CancellationToken ct = default);
+}
+
+// Implementation (in Infrastructure or Application layer)
+public class UserService : IUserService
+{
+    private readonly IRepository<User> _repository;
+    private readonly ILogger<UserService> _logger;
+
+    public UserService(IRepository<User> repository, ILogger<UserService> logger)
+    {
+        _repository = repository;
+        _logger = logger;
+    }
+
+    // Implementation...
+}
+\`\`\`
+
+### Dependency Injection
+
+\`\`\`csharp
+// In DependencyInjection.cs or ServiceCollectionExtensions.cs
+public static IServiceCollection AddApplicationServices(this IServiceCollection services)
+{
+    services.AddScoped<IUserService, UserService>();
+    services.AddScoped<IRoleService, RoleService>();
+    // ...
+    return services;
+}
+\`\`\`
+
+---
+
+## 5. Extension Patterns
+
+### Extending Services
+
+Use DI replacement to override core services:
+
+\`\`\`csharp
+// Your custom implementation
+public class CustomUserService : UserService, IUserService
+{
+    public CustomUserService(IRepository<User> repo, ILogger<CustomUserService> logger)
+        : base(repo, logger) { }
+
+    public override async Task<UserDto> GetByIdAsync(Guid id, CancellationToken ct = default)
+    {
+        // Custom logic before
+        var result = await base.GetByIdAsync(id, ct);
+        // Custom logic after
+        return result;
+    }
+}
+
+// Replace in DI
+services.Replace(ServiceDescriptor.Scoped<IUserService, CustomUserService>());
+\`\`\`
+
+### Extension Hooks
+
+Core services expose hooks for common extension points:
+
+\`\`\`csharp
+public interface IUserServiceHooks
+{
+    Task OnUserCreatedAsync(User user, CancellationToken ct);
+    Task OnUserUpdatedAsync(User user, CancellationToken ct);
+    Task OnUserDeletedAsync(Guid userId, CancellationToken ct);
+}
+\`\`\`
+
+---
+
+## 6. Configuration
+
+### appsettings.json Structure
+
+\`\`\`json
+{
+  "AtlasHub": {
+    "Licensing": {
+      "Key": "XXXX-XXXX-XXXX-XXXX",
+      "Validate": true
+    },
+    "Features": {
+      "AI": true,
+      "Support": true,
+      "Workflows": true
+    }
+  },
+  "Client": {
+    "Custom": {
+      // Client-specific configuration
+    }
+  }
+}
+\`\`\`
+
+---
+
+## Quick Reference
+
+| Category | Convention | Example |
+|----------|------------|---------|
+| Platform schema | \`${schemas.platform}\` | \`.ToTable("auth_Users", "${schemas.platform}")\` |
+| Extensions schema | \`${schemas.extensions}\` | \`.ToTable("client_Custom", "${schemas.extensions}")\` |
+| Table prefixes | \`${tablePrefixes.slice(0, 5).join(", ")}\`, etc. | \`auth_Users\`, \`nav_Modules\` |
+| Migration | \`YYYYMMDD_NNN_Description\` | \`20260115_001_InitialCreate\` |
+| Interface | \`I<Name>Service\` | \`IUserService\` |
+| Implementation | \`<Name>Service\` | \`UserService\` |
+| Domain namespace | \`${namespaces.domain}\` | - |
+| API namespace | \`${namespaces.api}\` | - |
+`;
+}
+
+// src/resources/project-info.ts
+import path9 from "path";
+var projectInfoResourceTemplate = {
+  uri: "smartstack://project",
+  name: "SmartStack Project Info",
+  description: "Current SmartStack project information, structure, and configuration",
+  mimeType: "text/markdown"
+};
+async function getProjectInfoResource(config) {
+  const projectPath = config.smartstack.projectPath;
+  const projectInfo = await detectProject(projectPath);
+  const structure = await findSmartStackStructure(projectPath);
+  const lines = [];
+  lines.push("# SmartStack Project Information");
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push(`| Property | Value |`);
+  lines.push(`|----------|-------|`);
+  lines.push(`| **Name** | ${projectInfo.name} |`);
+  lines.push(`| **Version** | ${projectInfo.version} |`);
+  lines.push(`| **Path** | \`${projectPath}\` |`);
+  lines.push(`| **Git Repository** | ${projectInfo.isGitRepo ? "Yes" : "No"} |`);
+  if (projectInfo.currentBranch) {
+    lines.push(`| **Current Branch** | \`${projectInfo.currentBranch}\` |`);
+  }
+  lines.push(`| **.NET Project** | ${projectInfo.hasDotNet ? "Yes" : "No"} |`);
+  lines.push(`| **EF Core** | ${projectInfo.hasEfCore ? "Yes" : "No"} |`);
+  if (projectInfo.dbContextName) {
+    lines.push(`| **DbContext** | \`${projectInfo.dbContextName}\` |`);
+  }
+  lines.push(`| **React Frontend** | ${projectInfo.hasReact ? "Yes" : "No"} |`);
+  lines.push("");
+  lines.push("## Project Structure");
+  lines.push("");
+  lines.push("```");
+  lines.push(`${projectInfo.name}/`);
+  if (structure.domain) {
+    lines.push(`\u251C\u2500\u2500 ${path9.basename(structure.domain)}/          # Domain layer (entities)`);
+  }
+  if (structure.application) {
+    lines.push(`\u251C\u2500\u2500 ${path9.basename(structure.application)}/     # Application layer (services)`);
+  }
+  if (structure.infrastructure) {
+    lines.push(`\u251C\u2500\u2500 ${path9.basename(structure.infrastructure)}/  # Infrastructure (EF Core)`);
+  }
+  if (structure.api) {
+    lines.push(`\u251C\u2500\u2500 ${path9.basename(structure.api)}/             # API layer (controllers)`);
+  }
+  if (structure.web) {
+    lines.push(`\u2514\u2500\u2500 web/smartstack-web/      # React frontend`);
+  }
+  lines.push("```");
+  lines.push("");
+  if (projectInfo.csprojFiles.length > 0) {
+    lines.push("## .NET Projects");
+    lines.push("");
+    lines.push("| Project | Path |");
+    lines.push("|---------|------|");
+    for (const csproj of projectInfo.csprojFiles) {
+      const name = path9.basename(csproj, ".csproj");
+      const relativePath = path9.relative(projectPath, csproj);
+      lines.push(`| ${name} | \`${relativePath}\` |`);
+    }
+    lines.push("");
+  }
+  if (structure.migrations) {
+    const migrationFiles = await findFiles("*.cs", {
+      cwd: structure.migrations,
+      ignore: ["*.Designer.cs"]
+    });
+    const migrations = migrationFiles.map((f) => path9.basename(f)).filter((f) => !f.includes("ModelSnapshot") && !f.includes(".Designer.")).sort();
+    lines.push("## EF Core Migrations");
+    lines.push("");
+    lines.push(`**Location**: \`${path9.relative(projectPath, structure.migrations)}\``);
+    lines.push(`**Total Migrations**: ${migrations.length}`);
+    lines.push("");
+    if (migrations.length > 0) {
+      lines.push("### Recent Migrations");
+      lines.push("");
+      const recent = migrations.slice(-5);
+      for (const migration of recent) {
+        lines.push(`- \`${migration.replace(".cs", "")}\``);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## Configuration");
+  lines.push("");
+  lines.push("### MCP Server Config");
+  lines.push("");
+  lines.push("```json");
+  lines.push(JSON.stringify({
+    smartstack: config.smartstack,
+    conventions: {
+      tablePrefix: config.conventions.tablePrefix,
+      migrationFormat: config.conventions.migrationFormat
+    }
+  }, null, 2));
+  lines.push("```");
+  lines.push("");
+  lines.push("## Quick Commands");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# Build the solution");
+  lines.push("dotnet build");
+  lines.push("");
+  lines.push("# Run API");
+  lines.push(`cd ${structure.api ? path9.relative(projectPath, structure.api) : "SmartStack.Api"}`);
+  lines.push("dotnet run");
+  lines.push("");
+  lines.push("# Run frontend");
+  lines.push(`cd ${structure.web ? path9.relative(projectPath, structure.web) : "web/smartstack-web"}`);
+  lines.push("npm run dev");
+  lines.push("");
+  lines.push("# Create migration");
+  lines.push("dotnet ef migrations add YYYYMMDD_Core_NNN_Description");
+  lines.push("");
+  lines.push("# Apply migrations");
+  lines.push("dotnet ef database update");
+  lines.push("```");
+  lines.push("");
+  lines.push("## Available MCP Tools");
+  lines.push("");
+  lines.push("| Tool | Description |");
+  lines.push("|------|-------------|");
+  lines.push("| `validate_conventions` | Check code against AtlasHub conventions |");
+  lines.push("| `check_migrations` | Analyze EF Core migrations for conflicts |");
+  lines.push("| `scaffold_extension` | Generate service, entity, controller, or component |");
+  lines.push("| `api_docs` | Get API endpoint documentation |");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/resources/api-endpoints.ts
+import path10 from "path";
+var apiEndpointsResourceTemplate = {
+  uri: "smartstack://api/",
+  name: "SmartStack API Endpoints",
+  description: "API endpoint documentation. Use smartstack://api/{endpoint} to filter.",
+  mimeType: "text/markdown"
+};
+async function getApiEndpointsResource(config, endpointFilter) {
+  const structure = await findSmartStackStructure(config.smartstack.projectPath);
+  if (!structure.api) {
+    return "# API Endpoints\n\nNo API project found.";
+  }
+  const controllerFiles = await findControllerFiles(structure.api);
+  const allEndpoints = [];
+  for (const file of controllerFiles) {
+    const endpoints2 = await parseController(file, structure.root);
+    allEndpoints.push(...endpoints2);
+  }
+  const endpoints = endpointFilter ? allEndpoints.filter(
+    (e) => e.path.toLowerCase().includes(endpointFilter.toLowerCase()) || e.controller.toLowerCase().includes(endpointFilter.toLowerCase())
+  ) : allEndpoints;
+  return formatEndpoints(endpoints, endpointFilter);
+}
+async function parseController(filePath, rootPath) {
+  const content = await readText(filePath);
+  const fileName = path10.basename(filePath, ".cs");
+  const controllerName = fileName.replace("Controller", "");
+  const endpoints = [];
+  const routeMatch = content.match(/\[Route\s*\(\s*"([^"]+)"\s*\)\]/);
+  const baseRoute = routeMatch ? routeMatch[1].replace("[controller]", controllerName.toLowerCase()) : `/api/${controllerName.toLowerCase()}`;
+  const classAuthorize = /\[Authorize\s*(?:\([^)]*\))?\s*\]\s*(?:\[.*\]\s*)*public\s+class/.test(content);
+  const methodPattern = /\/\/\/\s*<summary>\s*\n\s*\/\/\/\s*([^\n]+)\s*\n\s*\/\/\/\s*<\/summary>[\s\S]*?(?=\[Http)|(\[Http(Get|Post|Put|Patch|Delete)(?:\s*\(\s*"([^"]*)"\s*\))?\][\s\S]*?public\s+(?:async\s+)?(?:Task<)?(?:ActionResult<)?(\w+)(?:[<>[\],\s\w]*)?\s+(\w+)\s*\(([^)]*)\))/g;
+  let lastSummary = "";
+  let match;
+  const httpMethods = ["HttpGet", "HttpPost", "HttpPut", "HttpPatch", "HttpDelete"];
+  for (const httpMethod of httpMethods) {
+    const regex = new RegExp(
+      `\\[${httpMethod}(?:\\s*\\(\\s*"([^"]*)"\\s*\\))?\\]\\s*(?:\\[.*?\\]\\s*)*public\\s+(?:async\\s+)?(?:Task<)?(?:ActionResult<)?(\\w+)(?:[<>\\[\\],\\s\\w]*)?\\s+(\\w+)\\s*\\(([^)]*)\\)`,
+      "g"
+    );
+    while ((match = regex.exec(content)) !== null) {
+      const routeSuffix = match[1] || "";
+      const returnType = match[2];
+      const actionName = match[3];
+      const params = match[4];
+      let fullPath = baseRoute;
+      if (routeSuffix) {
+        fullPath = `${baseRoute}/${routeSuffix}`;
+      }
+      const parameters = parseParameters(params);
+      const methodAuthorize = content.substring(Math.max(0, match.index - 200), match.index).includes("[Authorize");
+      endpoints.push({
+        method: httpMethod.replace("Http", "").toUpperCase(),
+        path: fullPath.replace(/\/+/g, "/"),
+        controller: controllerName,
+        action: actionName,
+        parameters,
+        returnType,
+        authorize: classAuthorize || methodAuthorize
+      });
+    }
+  }
+  return endpoints;
+}
+function parseParameters(paramsString) {
+  if (!paramsString.trim()) return [];
+  const params = [];
+  const parts = paramsString.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/(\w+)\s*(?:=.*)?$/);
+    if (match) {
+      if (trimmed.includes("[FromBody]")) {
+        params.push(`body: ${match[1]}`);
+      } else if (trimmed.includes("[FromQuery]")) {
+        params.push(`query: ${match[1]}`);
+      } else if (trimmed.includes("[FromRoute]")) {
+        params.push(`route: ${match[1]}`);
+      } else {
+        params.push(match[1]);
+      }
+    }
+  }
+  return params;
+}
+function formatEndpoints(endpoints, filter) {
+  const lines = [];
+  lines.push("# SmartStack API Endpoints");
+  lines.push("");
+  if (filter) {
+    lines.push(`> Filtered by: \`${filter}\``);
+    lines.push("");
+  }
+  if (endpoints.length === 0) {
+    lines.push("No endpoints found matching the criteria.");
+    return lines.join("\n");
+  }
+  const byController = /* @__PURE__ */ new Map();
+  for (const endpoint of endpoints) {
+    const existing = byController.get(endpoint.controller) || [];
+    existing.push(endpoint);
+    byController.set(endpoint.controller, existing);
+  }
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`**Total Endpoints**: ${endpoints.length}`);
+  lines.push(`**Controllers**: ${byController.size}`);
+  lines.push("");
+  const methodCounts = /* @__PURE__ */ new Map();
+  for (const endpoint of endpoints) {
+    methodCounts.set(endpoint.method, (methodCounts.get(endpoint.method) || 0) + 1);
+  }
+  lines.push("| Method | Count |");
+  lines.push("|--------|-------|");
+  for (const [method, count] of methodCounts) {
+    lines.push(`| ${method} | ${count} |`);
+  }
+  lines.push("");
+  for (const [controller, controllerEndpoints] of byController) {
+    lines.push(`## ${controller}Controller`);
+    lines.push("");
+    controllerEndpoints.sort((a, b) => {
+      const pathCompare = a.path.localeCompare(b.path);
+      if (pathCompare !== 0) return pathCompare;
+      return a.method.localeCompare(b.method);
+    });
+    for (const endpoint of controllerEndpoints) {
+      const authBadge = endpoint.authorize ? " \u{1F512}" : "";
+      const methodColor = getMethodEmoji(endpoint.method);
+      lines.push(`### ${methodColor} \`${endpoint.method}\` ${endpoint.path}${authBadge}`);
+      lines.push("");
+      lines.push(`**Action**: \`${endpoint.action}\``);
+      lines.push(`**Returns**: \`${endpoint.returnType}\``);
+      if (endpoint.parameters.length > 0) {
+        lines.push("");
+        lines.push("**Parameters**:");
+        for (const param of endpoint.parameters) {
+          lines.push(`- \`${param}\``);
+        }
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## Quick Reference");
+  lines.push("");
+  lines.push("| Method | Path | Action | Auth |");
+  lines.push("|--------|------|--------|------|");
+  for (const endpoint of endpoints) {
+    lines.push(
+      `| ${endpoint.method} | \`${endpoint.path}\` | ${endpoint.action} | ${endpoint.authorize ? "\u{1F512}" : "\u2713"} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function getMethodEmoji(method) {
+  switch (method) {
+    case "GET":
+      return "\u{1F535}";
+    case "POST":
+      return "\u{1F7E2}";
+    case "PUT":
+      return "\u{1F7E1}";
+    case "PATCH":
+      return "\u{1F7E0}";
+    case "DELETE":
+      return "\u{1F534}";
+    default:
+      return "\u26AA";
+  }
+}
+
+// src/resources/db-schema.ts
+import path11 from "path";
+var dbSchemaResourceTemplate = {
+  uri: "smartstack://schema/",
+  name: "SmartStack Database Schema",
+  description: "Database schema information. Use smartstack://schema/{table} to get specific table.",
+  mimeType: "text/markdown"
+};
+async function getDbSchemaResource(config, tableFilter) {
+  const structure = await findSmartStackStructure(config.smartstack.projectPath);
+  if (!structure.domain && !structure.infrastructure) {
+    return "# Database Schema\n\nNo domain or infrastructure project found.";
+  }
+  const entities = [];
+  if (structure.domain) {
+    const entityFiles = await findEntityFiles(structure.domain);
+    for (const file of entityFiles) {
+      const entity = await parseEntity(file, structure.root, config);
+      if (entity) {
+        entities.push(entity);
+      }
+    }
+  }
+  if (structure.infrastructure) {
+    await enrichFromConfigurations(entities, structure.infrastructure, config);
+  }
+  const filteredEntities = tableFilter ? entities.filter(
+    (e) => e.name.toLowerCase().includes(tableFilter.toLowerCase()) || e.tableName.toLowerCase().includes(tableFilter.toLowerCase())
+  ) : entities;
+  return formatSchema(filteredEntities, tableFilter, config);
+}
+async function parseEntity(filePath, rootPath, config) {
+  const content = await readText(filePath);
+  const fileName = path11.basename(filePath, ".cs");
+  const classMatch = content.match(/public\s+(?:class|record)\s+(\w+)(?:\s*:\s*(\w+))?/);
+  if (!classMatch) return null;
+  const entityName = classMatch[1];
+  const baseClass = classMatch[2];
+  if (entityName.endsWith("Dto") || entityName.endsWith("Command") || entityName.endsWith("Query") || entityName.endsWith("Handler")) {
+    return null;
+  }
+  const properties = [];
+  const relationships = [];
+  const propertyPattern = /public\s+(?:required\s+)?(\w+(?:<[\w,\s]+>)?)\??\s+(\w+)\s*\{/g;
+  let match;
+  while ((match = propertyPattern.exec(content)) !== null) {
+    const propertyType = match[1];
+    const propertyName = match[2];
+    if (propertyType.startsWith("ICollection") || propertyType.startsWith("List")) {
+      const targetMatch = propertyType.match(/<(\w+)>/);
+      if (targetMatch) {
+        relationships.push({
+          type: "one-to-many",
+          targetEntity: targetMatch[1],
+          propertyName
+        });
+      }
+      continue;
+    }
+    const isNavigationProperty = /^[A-Z]/.test(propertyType) && ![
+      "Guid",
+      "String",
+      "Int32",
+      "Int64",
+      "DateTime",
+      "DateTimeOffset",
+      "Boolean",
+      "Decimal",
+      "Double",
+      "Float",
+      "Byte"
+    ].includes(propertyType) && !propertyType.includes("?");
+    if (isNavigationProperty && !propertyType.includes("<")) {
+      relationships.push({
+        type: "one-to-one",
+        targetEntity: propertyType,
+        propertyName
+      });
+      continue;
+    }
+    properties.push({
+      name: propertyName,
+      type: mapCSharpType(propertyType),
+      nullable: content.includes(`${propertyType}? ${propertyName}`) || content.includes(`${propertyType}?  ${propertyName}`),
+      isPrimaryKey: propertyName === "Id" || propertyName === `${entityName}Id`
+    });
+  }
+  const tableName = `${config.conventions.tablePrefix.core}${entityName}s`;
+  return {
+    name: entityName,
+    tableName,
+    properties,
+    relationships,
+    file: path11.relative(rootPath, filePath)
+  };
+}
+async function enrichFromConfigurations(entities, infrastructurePath, config) {
+  const configFiles = await findFiles("**/Configurations/**/*.cs", {
+    cwd: infrastructurePath
+  });
+  for (const file of configFiles) {
+    const content = await readText(file);
+    const tableMatch = content.match(/\.ToTable\s*\(\s*"([^"]+)"/);
+    if (tableMatch) {
+      const entityMatch = content.match(/IEntityTypeConfiguration<(\w+)>/);
+      if (entityMatch) {
+        const entityName = entityMatch[1];
+        const entity = entities.find((e) => e.name === entityName);
+        if (entity) {
+          entity.tableName = tableMatch[1];
+        }
+      }
+    }
+    const maxLengthMatches = content.matchAll(/\.Property\s*\(\s*\w+\s*=>\s*\w+\.(\w+)\s*\)[\s\S]*?\.HasMaxLength\s*\(\s*(\d+)\s*\)/g);
+    for (const match of maxLengthMatches) {
+      const propertyName = match[1];
+      const maxLength = parseInt(match[2], 10);
+      for (const entity of entities) {
+        const property = entity.properties.find((p) => p.name === propertyName);
+        if (property) {
+          property.maxLength = maxLength;
+        }
+      }
+    }
+  }
+}
+function mapCSharpType(csharpType) {
+  const typeMap = {
+    "Guid": "uniqueidentifier",
+    "string": "nvarchar",
+    "String": "nvarchar",
+    "int": "int",
+    "Int32": "int",
+    "long": "bigint",
+    "Int64": "bigint",
+    "DateTime": "datetime2",
+    "DateTimeOffset": "datetimeoffset",
+    "bool": "bit",
+    "Boolean": "bit",
+    "decimal": "decimal",
+    "Decimal": "decimal",
+    "double": "float",
+    "Double": "float",
+    "float": "real",
+    "Float": "real",
+    "byte[]": "varbinary"
+  };
+  const baseType = csharpType.replace("?", "");
+  return typeMap[baseType] || "nvarchar";
+}
+function formatSchema(entities, filter, config) {
+  const lines = [];
+  lines.push("# SmartStack Database Schema");
+  lines.push("");
+  if (filter) {
+    lines.push(`> Filtered by: \`${filter}\``);
+    lines.push("");
+  }
+  if (entities.length === 0) {
+    lines.push("No entities found matching the criteria.");
+    return lines.join("\n");
+  }
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`**Total Entities**: ${entities.length}`);
+  lines.push("");
+  lines.push("| Entity | Table | Properties | Relationships |");
+  lines.push("|--------|-------|------------|---------------|");
+  for (const entity of entities) {
+    lines.push(
+      `| ${entity.name} | \`${entity.tableName}\` | ${entity.properties.length} | ${entity.relationships.length} |`
+    );
+  }
+  lines.push("");
+  for (const entity of entities) {
+    lines.push(`## ${entity.name}`);
+    lines.push("");
+    lines.push(`**Table**: \`${entity.tableName}\``);
+    lines.push(`**File**: \`${entity.file}\``);
+    lines.push("");
+    lines.push("### Columns");
+    lines.push("");
+    lines.push("| Column | SQL Type | Nullable | Notes |");
+    lines.push("|--------|----------|----------|-------|");
+    for (const prop of entity.properties) {
+      const notes = [];
+      if (prop.isPrimaryKey) notes.push("PK");
+      if (prop.maxLength) notes.push(`MaxLength(${prop.maxLength})`);
+      lines.push(
+        `| ${prop.name} | ${prop.type} | ${prop.nullable ? "Yes" : "No"} | ${notes.join(", ")} |`
+      );
+    }
+    lines.push("");
+    if (entity.relationships.length > 0) {
+      lines.push("### Relationships");
+      lines.push("");
+      lines.push("| Type | Target | Property |");
+      lines.push("|------|--------|----------|");
+      for (const rel of entity.relationships) {
+        const typeIcon = rel.type === "one-to-one" ? "1:1" : rel.type === "one-to-many" ? "1:N" : "N:N";
+        lines.push(`| ${typeIcon} | ${rel.targetEntity} | ${rel.propertyName} |`);
+      }
+      lines.push("");
+    }
+    lines.push("### EF Core Configuration");
+    lines.push("");
+    lines.push("```csharp");
+    lines.push(`public class ${entity.name}Configuration : IEntityTypeConfiguration<${entity.name}>`);
+    lines.push("{");
+    lines.push(`    public void Configure(EntityTypeBuilder<${entity.name}> builder)`);
+    lines.push("    {");
+    lines.push(`        builder.ToTable("${entity.tableName}");`);
+    lines.push("");
+    const pk = entity.properties.find((p) => p.isPrimaryKey);
+    if (pk) {
+      lines.push(`        builder.HasKey(e => e.${pk.name});`);
+    }
+    lines.push("    }");
+    lines.push("}");
+    lines.push("```");
+    lines.push("");
+  }
+  if (entities.length > 1) {
+    lines.push("## Entity Relationships");
+    lines.push("");
+    lines.push("```");
+    for (const entity of entities) {
+      for (const rel of entity.relationships) {
+        const arrow = rel.type === "one-to-one" ? "\u2500\u2500" : rel.type === "one-to-many" ? "\u2500<" : ">\u2500<";
+        lines.push(`${entity.name} ${arrow} ${rel.targetEntity}`);
+      }
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/server.ts
+async function createServer() {
+  const config = await getConfig();
+  const server = new Server(
+    {
+      name: "smartstack-mcp",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logger.debug("Listing tools");
+    return {
+      tools: [
+        validateConventionsTool,
+        checkMigrationsTool,
+        scaffoldExtensionTool,
+        apiDocsTool
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const startTime = Date.now();
+    logger.toolStart(name, args);
+    try {
+      let result;
+      switch (name) {
+        case "validate_conventions":
+          result = await handleValidateConventions(args, config);
+          break;
+        case "check_migrations":
+          result = await handleCheckMigrations(args, config);
+          break;
+        case "scaffold_extension":
+          result = await handleScaffoldExtension(args, config);
+          break;
+        case "api_docs":
+          result = await handleApiDocs(args, config);
+          break;
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+      logger.toolEnd(name, true, Date.now() - startTime);
+      return {
+        content: [
+          {
+            type: "text",
+            text: result
+          }
+        ]
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      logger.toolError(name, err);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${err.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    logger.debug("Listing resources");
+    return {
+      resources: [
+        conventionsResourceTemplate,
+        projectInfoResourceTemplate,
+        apiEndpointsResourceTemplate,
+        dbSchemaResourceTemplate
+      ]
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    logger.debug("Reading resource", { uri });
+    try {
+      let content;
+      let mimeType = "text/markdown";
+      if (uri === "smartstack://conventions") {
+        content = await getConventionsResource(config);
+      } else if (uri === "smartstack://project") {
+        content = await getProjectInfoResource(config);
+      } else if (uri.startsWith("smartstack://api/")) {
+        const endpoint = uri.replace("smartstack://api/", "");
+        content = await getApiEndpointsResource(config, endpoint);
+      } else if (uri.startsWith("smartstack://schema/")) {
+        const table = uri.replace("smartstack://schema/", "");
+        content = await getDbSchemaResource(config, table);
+      } else {
+        throw new Error(`Unknown resource: ${uri}`);
+      }
+      return {
+        contents: [
+          {
+            uri,
+            mimeType,
+            text: content
+          }
+        ]
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      logger.error("Resource read failed", { uri, error: err.message });
+      throw err;
+    }
+  });
+  return server;
+}
+async function runServer() {
+  logger.info("Starting SmartStack MCP Server...");
+  const server = await createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("SmartStack MCP Server running on stdio");
+}
+
+// src/index.ts
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught exception", { error: error.message, stack: error.stack });
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  logger.error("Unhandled rejection", { reason });
+  process.exit(1);
+});
+runServer().catch((error) => {
+  logger.error("Failed to start server", { error: error.message });
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map