@codexa/cli 8.5.0

package/detectors/README.md

@@ -0,0 +1,110 @@
+# Universal Stack Detection System
+
+Sistema de detecção de stack agnóstico e modular para o Codexa Workflow.
+
+## Ecossistemas Suportados
+
+| Ecossistema | Marcadores Principais | Tecnologias Detectadas |
+|-------------|----------------------|------------------------|
+| **.NET** | `*.csproj`, `*.sln`, `*.fsproj` | ASP.NET Core, Blazor, EF Core, xUnit, NUnit |
+| **Node.js** | `package.json`, `*.lock` | Next.js, React, Vue, Express, Prisma, Drizzle |
+| **Python** | `pyproject.toml`, `requirements.txt` | Django, FastAPI, Flask, SQLAlchemy, pytest |
+| **Go** | `go.mod`, `go.sum` | Gin, Echo, Fiber, GORM, Ent |
+| **Rust** | `Cargo.toml`, `Cargo.lock` | Actix, Axum, Diesel, SeaORM, Tokio |
+| **JVM** | `pom.xml`, `build.gradle` | Spring Boot, Quarkus, Hibernate, JUnit |
+| **Flutter** | `pubspec.yaml` | Flutter, Riverpod, Bloc, Hive |
+
+## Arquitetura
+
+```
+detectors/
+├── index.ts      # Core: tipos, registro, utilities
+├── loader.ts     # Carrega todos os detectores
+├── dotnet.ts     # .NET/C#/F#
+├── node.ts       # Node.js/Bun/Deno
+├── python.ts     # Python
+├── go.ts         # Go
+├── rust.ts       # Rust
+├── jvm.ts        # Java/Kotlin/Scala
+└── flutter.ts    # Flutter/Dart
+```
+
+## Uso
+
+### Detecção Completa
+
+```typescript
+import { detectUniversal } from "./detectors/loader";
+
+const result = await detectUniversal();
+
+console.log(result.primary);      // { language, runtime, framework }
+console.log(result.ecosystems);   // ["dotnet", "node", ...]
+console.log(result.stack);        // { frontend, backend, database, ... }
+console.log(result.allTechnologies); // Full details with confidence
+```
+
+### Compatibilidade Legacy
+
+```typescript
+import { detectStackLegacy } from "./detectors/loader";
+
+const { stack, structure } = await detectStackLegacy();
+// Returns same format as old detectStack()/detectStructure()
+```
+
+## Adicionando Novo Detector
+
+```typescript
+// detectors/myecosystem.ts
+import { registerDetector, Detector } from "./index";
+
+const myDetector: Detector = {
+  name: "myecosystem",
+  ecosystem: "myecosystem",
+  priority: 50,
+  markers: [
+    { type: "file", pattern: "myconfig.json", weight: 1.0 },
+  ],
+
+  async detect(cwd: string) {
+    // Detection logic
+    return {
+      ecosystem: "myecosystem",
+      technologies: [...],
+      structure: {...},
+      configFiles: [...],
+    };
+  },
+};
+
+registerDetector(myDetector);
+```
+
+Depois adicione o import em `loader.ts`:
+
+```typescript
+import "./myecosystem";
+```
+
+## Categorias de Tecnologia
+
+- `runtime` - Linguagem/runtime (Node.js, .NET, Python)
+- `frontend` - Frameworks frontend (Next.js, React, Flutter)
+- `backend` - Frameworks backend (Express, ASP.NET, Django)
+- `database` - Bancos de dados (PostgreSQL, MongoDB, Redis)
+- `orm` - ORMs (Prisma, EF Core, SQLAlchemy)
+- `styling` - CSS/Styling (Tailwind, Styled Components)
+- `auth` - Autenticação (NextAuth, Firebase Auth)
+- `testing` - Testes (Jest, pytest, xUnit)
+- `build` - Build tools (Webpack, Gradle, Poetry)
+- `devops` - DevOps (Docker, Prometheus)
+
+## Confiança (Confidence)
+
+Cada tecnologia detectada tem um score de confiança (0-1):
+
+- **1.0**: Arquivo/configuração específica encontrada
+- **0.9**: Dependência explícita no manifest
+- **0.7-0.8**: Arquivos de código encontrados
+- **0.5-0.6**: Diretórios/estrutura inferida

package/detectors/dotnet.ts

@@ -0,0 +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);
+
+export default dotnetDetector;