@codexa/cli 8.6.0 → 8.6.9

package/detectors/dotnet.ts

@@ -1,358 +1,358 @@
-/**
- * .NET Ecosystem Detector
- *
- * Detects C#, F#, VB.NET projects including:
- * - ASP.NET Core (MVC, Web API, Razor, Blazor)
- * - .NET MAUI
- * - Entity Framework
- * - Dapper
- * - xUnit, NUnit, MSTest
- */
-
-import { join } from "path";
-import {
-  registerDetector,
-  Detector,
-  DetectorResult,
-  DetectedTechnology,
-  fileExists,
-  dirExists,
-  findFiles,
-  readText,
-} from "./index";
-
-interface CsprojInfo {
-  path: string;
-  sdk?: string;
-  targetFramework?: string;
-  packages: { name: string; version: string }[];
-  projectReferences: string[];
-}
-
-function parseCsproj(content: string): Partial<CsprojInfo> {
-  const result: Partial<CsprojInfo> = { packages: [], projectReferences: [] };
-
-  // Extract SDK
-  const sdkMatch = content.match(/<Project\s+Sdk="([^"]+)"/i);
-  if (sdkMatch) result.sdk = sdkMatch[1];
-
-  // Extract TargetFramework(s)
-  const tfMatch = content.match(/<TargetFramework>([^<]+)<\/TargetFramework>/i);
-  if (tfMatch) result.targetFramework = tfMatch[1];
-
-  const tfsMatch = content.match(/<TargetFrameworks>([^<]+)<\/TargetFrameworks>/i);
-  if (tfsMatch) result.targetFramework = tfsMatch[1].split(";")[0];
-
-  // Extract PackageReferences
-  const packageRegex = /<PackageReference\s+Include="([^"]+)"(?:\s+Version="([^"]+)")?/gi;
-  let match;
-  while ((match = packageRegex.exec(content)) !== null) {
-    result.packages!.push({ name: match[1], version: match[2] || "unknown" });
-  }
-
-  // Extract ProjectReferences
-  const projRefRegex = /<ProjectReference\s+Include="([^"]+)"/gi;
-  while ((match = projRefRegex.exec(content)) !== null) {
-    result.projectReferences!.push(match[1]);
-  }
-
-  return result;
-}
-
-function parseSln(content: string): string[] {
-  const projects: string[] = [];
-  const projectRegex = /Project\([^)]+\)\s*=\s*"[^"]+",\s*"([^"]+\.csproj)"/gi;
-  let match;
-  while ((match = projectRegex.exec(content)) !== null) {
-    projects.push(match[1].replace(/\\/g, "/"));
-  }
-  return projects;
-}
-
-const dotnetDetector: Detector = {
-  name: "dotnet",
-  ecosystem: "dotnet",
-  priority: 100,
-  markers: [
-    { type: "glob", pattern: "*.sln", weight: 1.0 },
-    { type: "glob", pattern: "*.csproj", weight: 1.0 },
-    { type: "glob", pattern: "**/*.csproj", weight: 0.9 },
-    { type: "glob", pattern: "*.fsproj", weight: 1.0 },
-    { type: "glob", pattern: "*.vbproj", weight: 1.0 },
-    { type: "file", pattern: "global.json", weight: 0.8 },
-    { type: "file", pattern: "nuget.config", weight: 0.6 },
-    { type: "file", pattern: "Directory.Build.props", weight: 0.7 },
-    { type: "directory", pattern: "obj", weight: 0.3 },
-    { type: "directory", pattern: "bin", weight: 0.3 },
-  ],
-
-  async detect(cwd: string): Promise<DetectorResult | null> {
-    const technologies: DetectedTechnology[] = [];
-    const structure: Record<string, string> = {};
-    const configFiles: string[] = [];
-
-    // Find all project files
-    const slnFiles = findFiles(cwd, "*.sln");
-    const csprojFiles = findFiles(cwd, "**/*.csproj");
-    const fsprojFiles = findFiles(cwd, "**/*.fsproj");
-
-    if (csprojFiles.length === 0 && fsprojFiles.length === 0 && slnFiles.length === 0) {
-      return null;
-    }
-
-    // Parse solution file if exists
-    if (slnFiles.length > 0) {
-      configFiles.push(slnFiles[0]);
-    }
-
-    // Track detected packages across all projects
-    const allPackages = new Map<string, string>();
-    const projectInfos: CsprojInfo[] = [];
-
-    // Parse each csproj
-    for (const csproj of csprojFiles) {
-      const content = readText(join(cwd, csproj));
-      if (!content) continue;
-
-      configFiles.push(csproj);
-      const info = parseCsproj(content);
-      info.path = csproj;
-      projectInfos.push(info as CsprojInfo);
-
-      for (const pkg of info.packages || []) {
-        allPackages.set(pkg.name.toLowerCase(), pkg.version);
-      }
-    }
-
-    // Determine primary SDK/framework type
-    const sdks = projectInfos.map(p => p.sdk).filter(Boolean);
-    const frameworks = projectInfos.map(p => p.targetFramework).filter(Boolean);
-
-    // Runtime detection
-    if (frameworks.length > 0) {
-      const framework = frameworks[0]!;
-      let runtimeName = ".NET";
-      let version = framework;
-
-      if (framework.startsWith("net8")) {
-        runtimeName = ".NET 8";
-        version = "8.0";
-      } else if (framework.startsWith("net7")) {
-        runtimeName = ".NET 7";
-        version = "7.0";
-      } else if (framework.startsWith("net6")) {
-        runtimeName = ".NET 6";
-        version = "6.0";
-      } else if (framework.startsWith("net5")) {
-        runtimeName = ".NET 5";
-        version = "5.0";
-      } else if (framework.startsWith("netcoreapp")) {
-        runtimeName = ".NET Core";
-        version = framework.replace("netcoreapp", "");
-      } else if (framework.startsWith("netstandard")) {
-        runtimeName = ".NET Standard";
-        version = framework.replace("netstandard", "");
-      } else if (framework.startsWith("net4")) {
-        runtimeName = ".NET Framework";
-        version = framework.replace("net", "");
-      }
-
-      technologies.push({
-        name: runtimeName,
-        version,
-        confidence: 1.0,
-        source: projectInfos[0]?.path || "csproj",
-        category: "runtime",
-        metadata: { targetFramework: framework },
-      });
-    }
-
-    // Backend framework detection
-    const backendFrameworks = [
-      { packages: ["microsoft.aspnetcore.app", "microsoft.aspnetcore"], name: "ASP.NET Core", category: "backend" as const },
-      { packages: ["microsoft.aspnetcore.mvc"], name: "ASP.NET Core MVC", category: "backend" as const },
-      { packages: ["microsoft.aspnetcore.components"], name: "Blazor", category: "frontend" as const },
-      { packages: ["microsoft.maui"], name: ".NET MAUI", category: "frontend" as const },
-      { packages: ["avalonia", "avalonia.desktop"], name: "Avalonia", category: "frontend" as const },
-      { packages: ["uno.ui"], name: "Uno Platform", category: "frontend" as const },
-    ];
-
-    // Check SDK for implicit framework
-    for (const sdk of sdks) {
-      if (sdk?.includes("Microsoft.NET.Sdk.Web")) {
-        technologies.push({
-          name: "ASP.NET Core",
-          confidence: 1.0,
-          source: "SDK",
-          category: "backend",
-        });
-      } else if (sdk?.includes("Microsoft.NET.Sdk.BlazorWebAssembly")) {
-        technologies.push({
-          name: "Blazor WebAssembly",
-          confidence: 1.0,
-          source: "SDK",
-          category: "frontend",
-        });
-      } else if (sdk?.includes("Microsoft.NET.Sdk.Razor")) {
-        technologies.push({
-          name: "Razor",
-          confidence: 0.9,
-          source: "SDK",
-          category: "frontend",
-        });
-      }
-    }
-
-    for (const fw of backendFrameworks) {
-      const found = fw.packages.find(p => allPackages.has(p));
-      if (found) {
-        technologies.push({
-          name: fw.name,
-          version: allPackages.get(found),
-          confidence: 0.95,
-          source: `Package: ${found}`,
-          category: fw.category,
-        });
-      }
-    }
-
-    // ORM detection
-    const ormMap = [
-      { packages: ["microsoft.entityframeworkcore", "entityframework"], name: "Entity Framework", category: "orm" as const },
-      { packages: ["dapper"], name: "Dapper", category: "orm" as const },
-      { packages: ["npgsql.entityframeworkcore.postgresql"], name: "EF Core + PostgreSQL", category: "orm" as const },
-      { packages: ["pomelo.entityframeworkcore.mysql"], name: "EF Core + MySQL", category: "orm" as const },
-      { packages: ["microsoft.entityframeworkcore.sqlserver"], name: "EF Core + SQL Server", category: "orm" as const },
-      { packages: ["microsoft.entityframeworkcore.sqlite"], name: "EF Core + SQLite", category: "orm" as const },
-      { packages: ["nhibernate"], name: "NHibernate", category: "orm" as const },
-    ];
-
-    for (const orm of ormMap) {
-      const found = orm.packages.find(p => allPackages.has(p));
-      if (found) {
-        technologies.push({
-          name: orm.name,
-          version: allPackages.get(found),
-          confidence: 0.95,
-          source: `Package: ${found}`,
-          category: orm.category,
-        });
-      }
-    }
-
-    // Database detection
-    const dbMap = [
-      { packages: ["npgsql"], name: "PostgreSQL", category: "database" as const },
-      { packages: ["mysql.data", "mysqlconnector"], name: "MySQL", category: "database" as const },
-      { packages: ["microsoft.data.sqlclient", "system.data.sqlclient"], name: "SQL Server", category: "database" as const },
-      { packages: ["microsoft.data.sqlite"], name: "SQLite", category: "database" as const },
-      { packages: ["mongodb.driver"], name: "MongoDB", category: "database" as const },
-      { packages: ["stackexchange.redis"], name: "Redis", category: "database" as const },
-    ];
-
-    for (const db of dbMap) {
-      const found = db.packages.find(p => allPackages.has(p));
-      if (found) {
-        technologies.push({
-          name: db.name,
-          version: allPackages.get(found),
-          confidence: 0.9,
-          source: `Package: ${found}`,
-          category: db.category,
-        });
-      }
-    }
-
-    // Testing framework detection
-    const testMap = [
-      { packages: ["xunit", "xunit.runner.visualstudio"], name: "xUnit", category: "testing" as const },
-      { packages: ["nunit", "nunit3testadapter"], name: "NUnit", category: "testing" as const },
-      { packages: ["mstest.testframework", "microsoft.net.test.sdk"], name: "MSTest", category: "testing" as const },
-      { packages: ["moq"], name: "Moq", category: "testing" as const },
-      { packages: ["nsubstitute"], name: "NSubstitute", category: "testing" as const },
-      { packages: ["fluentassertions"], name: "FluentAssertions", category: "testing" as const },
-      { packages: ["specflow"], name: "SpecFlow", category: "testing" as const },
-    ];
-
-    for (const test of testMap) {
-      const found = test.packages.find(p => allPackages.has(p));
-      if (found) {
-        technologies.push({
-          name: test.name,
-          version: allPackages.get(found),
-          confidence: 0.9,
-          source: `Package: ${found}`,
-          category: test.category,
-        });
-      }
-    }
-
-    // Auth detection
-    const authMap = [
-      { packages: ["microsoft.aspnetcore.authentication.jwtbearer"], name: "JWT Bearer", category: "auth" as const },
-      { packages: ["microsoft.aspnetcore.identity"], name: "ASP.NET Identity", category: "auth" as const },
-      { packages: ["identityserver4"], name: "IdentityServer4", category: "auth" as const },
-      { packages: ["duende.identityserver"], name: "Duende IdentityServer", category: "auth" as const },
-      { packages: ["microsoft.identity.web"], name: "Microsoft Identity Web", category: "auth" as const },
-    ];
-
-    for (const auth of authMap) {
-      const found = auth.packages.find(p => allPackages.has(p));
-      if (found) {
-        technologies.push({
-          name: auth.name,
-          version: allPackages.get(found),
-          confidence: 0.9,
-          source: `Package: ${found}`,
-          category: auth.category,
-        });
-      }
-    }
-
-    // Structure detection
-    const structurePaths = [
-      { key: "controllers", paths: ["Controllers", "Api/Controllers", "src/Controllers"] },
-      { key: "services", paths: ["Services", "src/Services", "Application/Services"] },
-      { key: "models", paths: ["Models", "Domain/Models", "Entities", "Domain/Entities"] },
-      { key: "data", paths: ["Data", "Infrastructure/Data", "Persistence"] },
-      { key: "api", paths: ["Api", "WebApi", "src/Api"] },
-      { key: "tests", paths: ["Tests", "test", "tests", "*.Tests"] },
-      { key: "migrations", paths: ["Migrations", "Data/Migrations"] },
-    ];
-
-    for (const { key, paths } of structurePaths) {
-      for (const p of paths) {
-        if (p.includes("*")) {
-          const matches = findFiles(cwd, p);
-          if (matches.length > 0) {
-            structure[key] = matches[0];
-            break;
-          }
-        } else if (dirExists(join(cwd, p))) {
-          structure[key] = p;
-          break;
-        }
-      }
-    }
-
-    // Check for config files
-    const dotnetConfigs = ["appsettings.json", "appsettings.Development.json", "launchSettings.json", "web.config"];
-    for (const cfg of dotnetConfigs) {
-      if (fileExists(join(cwd, cfg)) || findFiles(cwd, `**/${cfg}`).length > 0) {
-        configFiles.push(cfg);
-      }
-    }
-
-    return {
-      ecosystem: "dotnet",
-      technologies,
-      structure,
-      configFiles: [...new Set(configFiles)],
-    };
-  },
-};
-
-// Register the detector
-registerDetector(dotnetDetector);
-
+/**
+ * .NET Ecosystem Detector
+ *
+ * Detects C#, F#, VB.NET projects including:
+ * - ASP.NET Core (MVC, Web API, Razor, Blazor)
+ * - .NET MAUI
+ * - Entity Framework
+ * - Dapper
+ * - xUnit, NUnit, MSTest
+ */
+
+import { join } from "path";
+import {
+  registerDetector,
+  Detector,
+  DetectorResult,
+  DetectedTechnology,
+  fileExists,
+  dirExists,
+  findFiles,
+  readText,
+} from "./index";
+
+interface CsprojInfo {
+  path: string;
+  sdk?: string;
+  targetFramework?: string;
+  packages: { name: string; version: string }[];
+  projectReferences: string[];
+}
+
+function parseCsproj(content: string): Partial<CsprojInfo> {
+  const result: Partial<CsprojInfo> = { packages: [], projectReferences: [] };
+
+  // Extract SDK
+  const sdkMatch = content.match(/<Project\s+Sdk="([^"]+)"/i);
+  if (sdkMatch) result.sdk = sdkMatch[1];
+
+  // Extract TargetFramework(s)
+  const tfMatch = content.match(/<TargetFramework>([^<]+)<\/TargetFramework>/i);
+  if (tfMatch) result.targetFramework = tfMatch[1];
+
+  const tfsMatch = content.match(/<TargetFrameworks>([^<]+)<\/TargetFrameworks>/i);
+  if (tfsMatch) result.targetFramework = tfsMatch[1].split(";")[0];
+
+  // Extract PackageReferences
+  const packageRegex = /<PackageReference\s+Include="([^"]+)"(?:\s+Version="([^"]+)")?/gi;
+  let match;
+  while ((match = packageRegex.exec(content)) !== null) {
+    result.packages!.push({ name: match[1], version: match[2] || "unknown" });
+  }
+
+  // Extract ProjectReferences
+  const projRefRegex = /<ProjectReference\s+Include="([^"]+)"/gi;
+  while ((match = projRefRegex.exec(content)) !== null) {
+    result.projectReferences!.push(match[1]);
+  }
+
+  return result;
+}
+
+function parseSln(content: string): string[] {
+  const projects: string[] = [];
+  const projectRegex = /Project\([^)]+\)\s*=\s*"[^"]+",\s*"([^"]+\.csproj)"/gi;
+  let match;
+  while ((match = projectRegex.exec(content)) !== null) {
+    projects.push(match[1].replace(/\\/g, "/"));
+  }
+  return projects;
+}
+
+const dotnetDetector: Detector = {
+  name: "dotnet",
+  ecosystem: "dotnet",
+  priority: 100,
+  markers: [
+    { type: "glob", pattern: "*.sln", weight: 1.0 },
+    { type: "glob", pattern: "*.csproj", weight: 1.0 },
+    { type: "glob", pattern: "**/*.csproj", weight: 0.9 },
+    { type: "glob", pattern: "*.fsproj", weight: 1.0 },
+    { type: "glob", pattern: "*.vbproj", weight: 1.0 },
+    { type: "file", pattern: "global.json", weight: 0.8 },
+    { type: "file", pattern: "nuget.config", weight: 0.6 },
+    { type: "file", pattern: "Directory.Build.props", weight: 0.7 },
+    { type: "directory", pattern: "obj", weight: 0.3 },
+    { type: "directory", pattern: "bin", weight: 0.3 },
+  ],
+
+  async detect(cwd: string): Promise<DetectorResult | null> {
+    const technologies: DetectedTechnology[] = [];
+    const structure: Record<string, string> = {};
+    const configFiles: string[] = [];
+
+    // Find all project files
+    const slnFiles = findFiles(cwd, "*.sln");
+    const csprojFiles = findFiles(cwd, "**/*.csproj");
+    const fsprojFiles = findFiles(cwd, "**/*.fsproj");
+
+    if (csprojFiles.length === 0 && fsprojFiles.length === 0 && slnFiles.length === 0) {
+      return null;
+    }
+
+    // Parse solution file if exists
+    if (slnFiles.length > 0) {
+      configFiles.push(slnFiles[0]);
+    }
+
+    // Track detected packages across all projects
+    const allPackages = new Map<string, string>();
+    const projectInfos: CsprojInfo[] = [];
+
+    // Parse each csproj
+    for (const csproj of csprojFiles) {
+      const content = readText(join(cwd, csproj));
+      if (!content) continue;
+
+      configFiles.push(csproj);
+      const info = parseCsproj(content);
+      info.path = csproj;
+      projectInfos.push(info as CsprojInfo);
+
+      for (const pkg of info.packages || []) {
+        allPackages.set(pkg.name.toLowerCase(), pkg.version);
+      }
+    }
+
+    // Determine primary SDK/framework type
+    const sdks = projectInfos.map(p => p.sdk).filter(Boolean);
+    const frameworks = projectInfos.map(p => p.targetFramework).filter(Boolean);
+
+    // Runtime detection
+    if (frameworks.length > 0) {
+      const framework = frameworks[0]!;
+      let runtimeName = ".NET";
+      let version = framework;
+
+      if (framework.startsWith("net8")) {
+        runtimeName = ".NET 8";
+        version = "8.0";
+      } else if (framework.startsWith("net7")) {
+        runtimeName = ".NET 7";
+        version = "7.0";
+      } else if (framework.startsWith("net6")) {
+        runtimeName = ".NET 6";
+        version = "6.0";
+      } else if (framework.startsWith("net5")) {
+        runtimeName = ".NET 5";
+        version = "5.0";
+      } else if (framework.startsWith("netcoreapp")) {
+        runtimeName = ".NET Core";
+        version = framework.replace("netcoreapp", "");
+      } else if (framework.startsWith("netstandard")) {
+        runtimeName = ".NET Standard";
+        version = framework.replace("netstandard", "");
+      } else if (framework.startsWith("net4")) {
+        runtimeName = ".NET Framework";
+        version = framework.replace("net", "");
+      }
+
+      technologies.push({
+        name: runtimeName,
+        version,
+        confidence: 1.0,
+        source: projectInfos[0]?.path || "csproj",
+        category: "runtime",
+        metadata: { targetFramework: framework },
+      });
+    }
+
+    // Backend framework detection
+    const backendFrameworks = [
+      { packages: ["microsoft.aspnetcore.app", "microsoft.aspnetcore"], name: "ASP.NET Core", category: "backend" as const },
+      { packages: ["microsoft.aspnetcore.mvc"], name: "ASP.NET Core MVC", category: "backend" as const },
+      { packages: ["microsoft.aspnetcore.components"], name: "Blazor", category: "frontend" as const },
+      { packages: ["microsoft.maui"], name: ".NET MAUI", category: "frontend" as const },
+      { packages: ["avalonia", "avalonia.desktop"], name: "Avalonia", category: "frontend" as const },
+      { packages: ["uno.ui"], name: "Uno Platform", category: "frontend" as const },
+    ];
+
+    // Check SDK for implicit framework
+    for (const sdk of sdks) {
+      if (sdk?.includes("Microsoft.NET.Sdk.Web")) {
+        technologies.push({
+          name: "ASP.NET Core",
+          confidence: 1.0,
+          source: "SDK",
+          category: "backend",
+        });
+      } else if (sdk?.includes("Microsoft.NET.Sdk.BlazorWebAssembly")) {
+        technologies.push({
+          name: "Blazor WebAssembly",
+          confidence: 1.0,
+          source: "SDK",
+          category: "frontend",
+        });
+      } else if (sdk?.includes("Microsoft.NET.Sdk.Razor")) {
+        technologies.push({
+          name: "Razor",
+          confidence: 0.9,
+          source: "SDK",
+          category: "frontend",
+        });
+      }
+    }
+
+    for (const fw of backendFrameworks) {
+      const found = fw.packages.find(p => allPackages.has(p));
+      if (found) {
+        technologies.push({
+          name: fw.name,
+          version: allPackages.get(found),
+          confidence: 0.95,
+          source: `Package: ${found}`,
+          category: fw.category,
+        });
+      }
+    }
+
+    // ORM detection
+    const ormMap = [
+      { packages: ["microsoft.entityframeworkcore", "entityframework"], name: "Entity Framework", category: "orm" as const },
+      { packages: ["dapper"], name: "Dapper", category: "orm" as const },
+      { packages: ["npgsql.entityframeworkcore.postgresql"], name: "EF Core + PostgreSQL", category: "orm" as const },
+      { packages: ["pomelo.entityframeworkcore.mysql"], name: "EF Core + MySQL", category: "orm" as const },
+      { packages: ["microsoft.entityframeworkcore.sqlserver"], name: "EF Core + SQL Server", category: "orm" as const },
+      { packages: ["microsoft.entityframeworkcore.sqlite"], name: "EF Core + SQLite", category: "orm" as const },
+      { packages: ["nhibernate"], name: "NHibernate", category: "orm" as const },
+    ];
+
+    for (const orm of ormMap) {
+      const found = orm.packages.find(p => allPackages.has(p));
+      if (found) {
+        technologies.push({
+          name: orm.name,
+          version: allPackages.get(found),
+          confidence: 0.95,
+          source: `Package: ${found}`,
+          category: orm.category,
+        });
+      }
+    }
+
+    // Database detection
+    const dbMap = [
+      { packages: ["npgsql"], name: "PostgreSQL", category: "database" as const },
+      { packages: ["mysql.data", "mysqlconnector"], name: "MySQL", category: "database" as const },
+      { packages: ["microsoft.data.sqlclient", "system.data.sqlclient"], name: "SQL Server", category: "database" as const },
+      { packages: ["microsoft.data.sqlite"], name: "SQLite", category: "database" as const },
+      { packages: ["mongodb.driver"], name: "MongoDB", category: "database" as const },
+      { packages: ["stackexchange.redis"], name: "Redis", category: "database" as const },
+    ];
+
+    for (const db of dbMap) {
+      const found = db.packages.find(p => allPackages.has(p));
+      if (found) {
+        technologies.push({
+          name: db.name,
+          version: allPackages.get(found),
+          confidence: 0.9,
+          source: `Package: ${found}`,
+          category: db.category,
+        });
+      }
+    }
+
+    // Testing framework detection
+    const testMap = [
+      { packages: ["xunit", "xunit.runner.visualstudio"], name: "xUnit", category: "testing" as const },
+      { packages: ["nunit", "nunit3testadapter"], name: "NUnit", category: "testing" as const },
+      { packages: ["mstest.testframework", "microsoft.net.test.sdk"], name: "MSTest", category: "testing" as const },
+      { packages: ["moq"], name: "Moq", category: "testing" as const },
+      { packages: ["nsubstitute"], name: "NSubstitute", category: "testing" as const },
+      { packages: ["fluentassertions"], name: "FluentAssertions", category: "testing" as const },
+      { packages: ["specflow"], name: "SpecFlow", category: "testing" as const },
+    ];
+
+    for (const test of testMap) {
+      const found = test.packages.find(p => allPackages.has(p));
+      if (found) {
+        technologies.push({
+          name: test.name,
+          version: allPackages.get(found),
+          confidence: 0.9,
+          source: `Package: ${found}`,
+          category: test.category,
+        });
+      }
+    }
+
+    // Auth detection
+    const authMap = [
+      { packages: ["microsoft.aspnetcore.authentication.jwtbearer"], name: "JWT Bearer", category: "auth" as const },
+      { packages: ["microsoft.aspnetcore.identity"], name: "ASP.NET Identity", category: "auth" as const },
+      { packages: ["identityserver4"], name: "IdentityServer4", category: "auth" as const },
+      { packages: ["duende.identityserver"], name: "Duende IdentityServer", category: "auth" as const },
+      { packages: ["microsoft.identity.web"], name: "Microsoft Identity Web", category: "auth" as const },
+    ];
+
+    for (const auth of authMap) {
+      const found = auth.packages.find(p => allPackages.has(p));
+      if (found) {
+        technologies.push({
+          name: auth.name,
+          version: allPackages.get(found),
+          confidence: 0.9,
+          source: `Package: ${found}`,
+          category: auth.category,
+        });
+      }
+    }
+
+    // Structure detection
+    const structurePaths = [
+      { key: "controllers", paths: ["Controllers", "Api/Controllers", "src/Controllers"] },
+      { key: "services", paths: ["Services", "src/Services", "Application/Services"] },
+      { key: "models", paths: ["Models", "Domain/Models", "Entities", "Domain/Entities"] },
+      { key: "data", paths: ["Data", "Infrastructure/Data", "Persistence"] },
+      { key: "api", paths: ["Api", "WebApi", "src/Api"] },
+      { key: "tests", paths: ["Tests", "test", "tests", "*.Tests"] },
+      { key: "migrations", paths: ["Migrations", "Data/Migrations"] },
+    ];
+
+    for (const { key, paths } of structurePaths) {
+      for (const p of paths) {
+        if (p.includes("*")) {
+          const matches = findFiles(cwd, p);
+          if (matches.length > 0) {
+            structure[key] = matches[0];
+            break;
+          }
+        } else if (dirExists(join(cwd, p))) {
+          structure[key] = p;
+          break;
+        }
+      }
+    }
+
+    // Check for config files
+    const dotnetConfigs = ["appsettings.json", "appsettings.Development.json", "launchSettings.json", "web.config"];
+    for (const cfg of dotnetConfigs) {
+      if (fileExists(join(cwd, cfg)) || findFiles(cwd, `**/${cfg}`).length > 0) {
+        configFiles.push(cfg);
+      }
+    }
+
+    return {
+      ecosystem: "dotnet",
+      technologies,
+      structure,
+      configFiles: [...new Set(configFiles)],
+    };
+  },
+};
+
+// Register the detector
+registerDetector(dotnetDetector);
+
 export default dotnetDetector;