@codexa/cli 8.5.0

package/detectors/jvm.ts

@@ -0,0 +1,434 @@
+/**
+ * JVM Ecosystem Detector (Java/Kotlin/Scala)
+ *
+ * Detects JVM projects including:
+ * - Build tools: Maven, Gradle, sbt
+ * - Frameworks: Spring Boot, Quarkus, Micronaut, Ktor
+ * - ORMs: Hibernate, JPA, Exposed, jOOQ
+ * - Testing: JUnit, TestNG, Kotest, Mockito
+ */
+
+import { join } from "path";
+import {
+  registerDetector,
+  Detector,
+  DetectorResult,
+  DetectedTechnology,
+  fileExists,
+  dirExists,
+  findFiles,
+  readText,
+} from "./index";
+
+interface MavenDependency {
+  groupId: string;
+  artifactId: string;
+  version?: string;
+}
+
+function parsePomXml(content: string): { dependencies: MavenDependency[]; parent?: MavenDependency } {
+  const result: { dependencies: MavenDependency[]; parent?: MavenDependency } = { dependencies: [] };
+
+  // Parse parent
+  const parentMatch = content.match(/<parent>([\s\S]*?)<\/parent>/);
+  if (parentMatch) {
+    const groupIdMatch = parentMatch[1].match(/<groupId>([^<]+)<\/groupId>/);
+    const artifactIdMatch = parentMatch[1].match(/<artifactId>([^<]+)<\/artifactId>/);
+    const versionMatch = parentMatch[1].match(/<version>([^<]+)<\/version>/);
+    if (groupIdMatch && artifactIdMatch) {
+      result.parent = {
+        groupId: groupIdMatch[1],
+        artifactId: artifactIdMatch[1],
+        version: versionMatch?.[1],
+      };
+    }
+  }
+
+  // Parse dependencies
+  const depsMatch = content.match(/<dependencies>([\s\S]*?)<\/dependencies>/);
+  if (depsMatch) {
+    const depRegex = /<dependency>([\s\S]*?)<\/dependency>/g;
+    let match;
+    while ((match = depRegex.exec(depsMatch[1])) !== null) {
+      const groupIdMatch = match[1].match(/<groupId>([^<]+)<\/groupId>/);
+      const artifactIdMatch = match[1].match(/<artifactId>([^<]+)<\/artifactId>/);
+      const versionMatch = match[1].match(/<version>([^<]+)<\/version>/);
+      if (groupIdMatch && artifactIdMatch) {
+        result.dependencies.push({
+          groupId: groupIdMatch[1],
+          artifactId: artifactIdMatch[1],
+          version: versionMatch?.[1],
+        });
+      }
+    }
+  }
+
+  return result;
+}
+
+function parseGradleDependencies(content: string): string[] {
+  const deps: string[] = [];
+
+  // Match various dependency patterns
+  const patterns = [
+    /implementation\s*['"(]([^'")\s]+)['")\s]/g,
+    /api\s*['"(]([^'")\s]+)['")\s]/g,
+    /compileOnly\s*['"(]([^'")\s]+)['")\s]/g,
+    /runtimeOnly\s*['"(]([^'")\s]+)['")\s]/g,
+    /testImplementation\s*['"(]([^'")\s]+)['")\s]/g,
+    /implementation\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  ];
+
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      deps.push(match[1]);
+    }
+  }
+
+  return deps;
+}
+
+const jvmDetector: Detector = {
+  name: "jvm",
+  ecosystem: "java",
+  priority: 70,
+  markers: [
+    { type: "file", pattern: "pom.xml", weight: 1.0 },
+    { type: "file", pattern: "build.gradle", weight: 1.0 },
+    { type: "file", pattern: "build.gradle.kts", weight: 1.0 },
+    { type: "file", pattern: "settings.gradle", weight: 0.9 },
+    { type: "file", pattern: "settings.gradle.kts", weight: 0.9 },
+    { type: "file", pattern: "build.sbt", weight: 1.0 },
+    { type: "file", pattern: "gradlew", weight: 0.8 },
+    { type: "file", pattern: "mvnw", weight: 0.8 },
+    { type: "glob", pattern: "**/*.java", weight: 0.7 },
+    { type: "glob", pattern: "**/*.kt", weight: 0.7 },
+    { type: "glob", pattern: "**/*.scala", weight: 0.7 },
+    { type: "directory", pattern: "src/main/java", weight: 0.8 },
+    { type: "directory", pattern: "src/main/kotlin", weight: 0.8 },
+  ],
+
+  async detect(cwd: string): Promise<DetectorResult | null> {
+    const technologies: DetectedTechnology[] = [];
+    const structure: Record<string, string> = {};
+    const configFiles: string[] = [];
+
+    // Detect build tool and collect dependencies
+    const allDeps = new Set<string>();
+    let buildTool = "";
+    let language = "Java";
+
+    // Check for Maven
+    if (fileExists(join(cwd, "pom.xml"))) {
+      buildTool = "Maven";
+      configFiles.push("pom.xml");
+      if (fileExists(join(cwd, "mvnw"))) configFiles.push("mvnw");
+
+      const pomContent = readText(join(cwd, "pom.xml"));
+      if (pomContent) {
+        const pom = parsePomXml(pomContent);
+
+        // Check parent for Spring Boot
+        if (pom.parent?.artifactId === "spring-boot-starter-parent") {
+          allDeps.add("spring-boot");
+        }
+
+        for (const dep of pom.dependencies) {
+          allDeps.add(`${dep.groupId}:${dep.artifactId}`);
+          allDeps.add(dep.artifactId);
+        }
+      }
+
+      technologies.push({
+        name: "Maven",
+        confidence: 1.0,
+        source: "pom.xml",
+        category: "build",
+      });
+    }
+
+    // Check for Gradle
+    const gradleFile = fileExists(join(cwd, "build.gradle.kts"))
+      ? "build.gradle.kts"
+      : fileExists(join(cwd, "build.gradle"))
+        ? "build.gradle"
+        : null;
+
+    if (gradleFile) {
+      buildTool = "Gradle";
+      configFiles.push(gradleFile);
+      if (fileExists(join(cwd, "gradlew"))) configFiles.push("gradlew");
+      if (fileExists(join(cwd, "settings.gradle.kts"))) configFiles.push("settings.gradle.kts");
+      else if (fileExists(join(cwd, "settings.gradle"))) configFiles.push("settings.gradle");
+
+      const gradleContent = readText(join(cwd, gradleFile));
+      if (gradleContent) {
+        const deps = parseGradleDependencies(gradleContent);
+        for (const dep of deps) {
+          allDeps.add(dep);
+          // Also add artifact name
+          const parts = dep.split(":");
+          if (parts.length >= 2) {
+            allDeps.add(parts[1]);
+          }
+        }
+
+        // Check for Kotlin
+        if (gradleContent.includes("kotlin(") || gradleContent.includes("org.jetbrains.kotlin")) {
+          language = "Kotlin";
+        }
+      }
+
+      technologies.push({
+        name: "Gradle",
+        confidence: 1.0,
+        source: gradleFile,
+        category: "build",
+      });
+    }
+
+    // Check for sbt (Scala)
+    if (fileExists(join(cwd, "build.sbt"))) {
+      buildTool = "sbt";
+      language = "Scala";
+      configFiles.push("build.sbt");
+
+      technologies.push({
+        name: "sbt",
+        confidence: 1.0,
+        source: "build.sbt",
+        category: "build",
+      });
+    }
+
+    // No build tool found - check for source files
+    if (!buildTool) {
+      const javaFiles = findFiles(cwd, "**/*.java");
+      const ktFiles = findFiles(cwd, "**/*.kt");
+      const scalaFiles = findFiles(cwd, "**/*.scala");
+
+      if (javaFiles.length === 0 && ktFiles.length === 0 && scalaFiles.length === 0) {
+        return null;
+      }
+
+      if (ktFiles.length > javaFiles.length) language = "Kotlin";
+      else if (scalaFiles.length > javaFiles.length) language = "Scala";
+    }
+
+    // Detect language from files
+    if (dirExists(join(cwd, "src/main/kotlin")) || findFiles(cwd, "**/*.kt").length > 0) {
+      if (language !== "Scala") language = "Kotlin";
+    }
+    if (dirExists(join(cwd, "src/main/scala")) || findFiles(cwd, "**/*.scala").length > 0) {
+      language = "Scala";
+    }
+
+    // Add language as runtime
+    technologies.push({
+      name: language,
+      confidence: 1.0,
+      source: "Source files",
+      category: "runtime",
+    });
+
+    // Web Framework Detection
+    const webFrameworks = [
+      { deps: ["spring-boot", "spring-boot-starter-web", "org.springframework.boot:spring-boot-starter-web"], name: "Spring Boot", confidence: 1.0 },
+      { deps: ["spring-webflux", "spring-boot-starter-webflux"], name: "Spring WebFlux", confidence: 1.0 },
+      { deps: ["io.quarkus", "quarkus-core", "quarkus-resteasy"], name: "Quarkus", confidence: 1.0 },
+      { deps: ["io.micronaut", "micronaut-core", "micronaut-http-server"], name: "Micronaut", confidence: 1.0 },
+      { deps: ["io.ktor", "ktor-server-core", "ktor-server"], name: "Ktor", confidence: 1.0 },
+      { deps: ["io.vertx", "vertx-core", "vertx-web"], name: "Vert.x", confidence: 1.0 },
+      { deps: ["io.helidon", "helidon-webserver"], name: "Helidon", confidence: 1.0 },
+      { deps: ["dropwizard", "io.dropwizard"], name: "Dropwizard", confidence: 1.0 },
+      { deps: ["spark-core", "com.sparkjava:spark-core"], name: "Spark Java", confidence: 1.0 },
+      { deps: ["javalin", "io.javalin"], name: "Javalin", confidence: 1.0 },
+    ];
+
+    for (const fw of webFrameworks) {
+      const found = fw.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: fw.name,
+          confidence: fw.confidence,
+          source: `Dependency: ${found}`,
+          category: "backend",
+        });
+        break;
+      }
+    }
+
+    // ORM/Database Detection
+    const orms = [
+      { deps: ["hibernate-core", "org.hibernate"], name: "Hibernate", confidence: 1.0 },
+      { deps: ["spring-data-jpa", "spring-boot-starter-data-jpa"], name: "Spring Data JPA", confidence: 1.0 },
+      { deps: ["mybatis", "org.mybatis"], name: "MyBatis", confidence: 1.0 },
+      { deps: ["exposed", "org.jetbrains.exposed"], name: "Exposed", confidence: 1.0 },
+      { deps: ["jooq", "org.jooq"], name: "jOOQ", confidence: 1.0 },
+      { deps: ["ebean", "io.ebean"], name: "Ebean", confidence: 1.0 },
+      { deps: ["jdbi", "org.jdbi"], name: "JDBI", confidence: 1.0 },
+      { deps: ["slick", "com.typesafe.slick"], name: "Slick", confidence: 1.0 },
+    ];
+
+    for (const orm of orms) {
+      const found = orm.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: orm.name,
+          confidence: orm.confidence,
+          source: `Dependency: ${found}`,
+          category: "orm",
+        });
+      }
+    }
+
+    // Database Drivers
+    const dbDrivers = [
+      { deps: ["postgresql", "org.postgresql"], name: "PostgreSQL", confidence: 0.9 },
+      { deps: ["mysql-connector-java", "mysql-connector-j", "com.mysql"], name: "MySQL", confidence: 0.9 },
+      { deps: ["h2", "com.h2database"], name: "H2", confidence: 0.9 },
+      { deps: ["mongodb-driver", "org.mongodb"], name: "MongoDB", confidence: 0.9 },
+      { deps: ["jedis", "lettuce-core", "redis.clients"], name: "Redis", confidence: 0.9 },
+      { deps: ["elasticsearch-java", "elasticsearch-rest-client"], name: "Elasticsearch", confidence: 0.9 },
+      { deps: ["cassandra-driver", "datastax"], name: "Cassandra", confidence: 0.9 },
+    ];
+
+    const detectedDbs = new Set<string>();
+    for (const db of dbDrivers) {
+      const found = db.deps.find(d => allDeps.has(d));
+      if (found && !detectedDbs.has(db.name)) {
+        technologies.push({
+          name: db.name,
+          confidence: db.confidence,
+          source: `Dependency: ${found}`,
+          category: "database",
+        });
+        detectedDbs.add(db.name);
+      }
+    }
+
+    // Testing Frameworks
+    const testingTools = [
+      { deps: ["junit-jupiter", "org.junit.jupiter", "junit"], name: "JUnit", confidence: 1.0 },
+      { deps: ["testng", "org.testng"], name: "TestNG", confidence: 1.0 },
+      { deps: ["kotest", "io.kotest"], name: "Kotest", confidence: 1.0 },
+      { deps: ["mockito", "org.mockito"], name: "Mockito", confidence: 0.95 },
+      { deps: ["mockk", "io.mockk"], name: "MockK", confidence: 0.95 },
+      { deps: ["assertj", "org.assertj"], name: "AssertJ", confidence: 0.9 },
+      { deps: ["spock", "org.spockframework"], name: "Spock", confidence: 1.0 },
+      { deps: ["scalatest", "org.scalatest"], name: "ScalaTest", confidence: 1.0 },
+    ];
+
+    for (const test of testingTools) {
+      const found = test.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: test.name,
+          confidence: test.confidence,
+          source: `Dependency: ${found}`,
+          category: "testing",
+        });
+      }
+    }
+
+    // Security/Auth
+    const authTools = [
+      { deps: ["spring-security", "spring-boot-starter-security"], name: "Spring Security", confidence: 1.0 },
+      { deps: ["keycloak", "org.keycloak"], name: "Keycloak", confidence: 1.0 },
+      { deps: ["nimbus-jose-jwt", "com.nimbusds"], name: "Nimbus JOSE JWT", confidence: 0.9 },
+      { deps: ["java-jwt", "com.auth0:java-jwt"], name: "Auth0 JWT", confidence: 0.9 },
+      { deps: ["pac4j", "org.pac4j"], name: "PAC4J", confidence: 1.0 },
+    ];
+
+    for (const auth of authTools) {
+      const found = auth.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: auth.name,
+          confidence: auth.confidence,
+          source: `Dependency: ${found}`,
+          category: "auth",
+        });
+      }
+    }
+
+    // DevOps/Observability
+    const devopsTools = [
+      { deps: ["lombok", "org.projectlombok"], name: "Lombok", confidence: 0.9 },
+      { deps: ["micrometer", "io.micrometer"], name: "Micrometer", confidence: 0.9 },
+      { deps: ["spring-boot-actuator", "spring-boot-starter-actuator"], name: "Spring Actuator", confidence: 0.95 },
+      { deps: ["logback", "ch.qos.logback"], name: "Logback", confidence: 0.85 },
+      { deps: ["log4j", "org.apache.logging.log4j"], name: "Log4j", confidence: 0.85 },
+      { deps: ["opentelemetry", "io.opentelemetry"], name: "OpenTelemetry", confidence: 0.9 },
+    ];
+
+    for (const tool of devopsTools) {
+      const found = tool.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: tool.name,
+          confidence: tool.confidence,
+          source: `Dependency: ${found}`,
+          category: "devops",
+        });
+      }
+    }
+
+    // Structure detection (standard Maven/Gradle layout)
+    const structurePaths = [
+      { key: "main", paths: ["src/main/java", "src/main/kotlin", "src/main/scala"] },
+      { key: "test", paths: ["src/test/java", "src/test/kotlin", "src/test/scala"] },
+      { key: "resources", paths: ["src/main/resources"] },
+      { key: "testResources", paths: ["src/test/resources"] },
+      { key: "controllers", paths: ["src/main/java/controller", "src/main/java/controllers", "src/main/kotlin/controller"] },
+      { key: "services", paths: ["src/main/java/service", "src/main/java/services", "src/main/kotlin/service"] },
+      { key: "repository", paths: ["src/main/java/repository", "src/main/java/repositories", "src/main/kotlin/repository"] },
+      { key: "models", paths: ["src/main/java/model", "src/main/java/models", "src/main/java/entity", "src/main/kotlin/model"] },
+      { key: "config", paths: ["src/main/java/config", "src/main/java/configuration", "src/main/kotlin/config"] },
+    ];
+
+    for (const { key, paths } of structurePaths) {
+      for (const p of paths) {
+        if (dirExists(join(cwd, p))) {
+          structure[key] = p;
+          break;
+        }
+      }
+    }
+
+    // Config files
+    const configPatterns = [
+      "application.properties",
+      "application.yml",
+      "application.yaml",
+      "application-dev.properties",
+      "application-dev.yml",
+      "bootstrap.properties",
+      "bootstrap.yml",
+      "lombok.config",
+      "checkstyle.xml",
+      "spotbugs.xml",
+      "Dockerfile",
+      "docker-compose.yml",
+    ];
+
+    for (const pattern of configPatterns) {
+      if (fileExists(join(cwd, pattern)) || fileExists(join(cwd, "src/main/resources", pattern))) {
+        configFiles.push(pattern);
+      }
+    }
+
+    return {
+      ecosystem: "java",
+      technologies,
+      structure,
+      configFiles: [...new Set(configFiles)],
+    };
+  },
+};
+
+// Register the detector
+registerDetector(jvmDetector);
+
+export default jvmDetector;

package/detectors/loader.ts

@@ -0,0 +1,141 @@
+/**
+ * Detector Loader
+ *
+ * Loads all ecosystem detectors and provides unified detection API.
+ * This module should be imported once to register all detectors.
+ */
+
+// Import all detectors to register them
+import "./dotnet";
+import "./node";
+import "./python";
+import "./go";
+import "./rust";
+import "./jvm";
+import "./flutter";
+
+// Re-export main functions from index
+export {
+  detectUniversal,
+  detectStackLegacy,
+  getDetectors,
+  type UnifiedDetectionResult,
+  type LegacyStackDetection,
+  type LegacyStructureDetection,
+  type DetectedTechnology,
+  type DetectorResult,
+} from "./index";
+
+// Re-export utilities for custom detectors
+export {
+  registerDetector,
+  fileExists,
+  dirExists,
+  findFiles,
+  readJson,
+  readText,
+  parseToml,
+  parseYaml,
+} from "./index";
+
+/**
+ * Convenience function for CLI display
+ */
+export function formatDetectionResult(result: import("./index").UnifiedDetectionResult): string {
+  const lines: string[] = [];
+
+  lines.push("═".repeat(60));
+  lines.push("STACK DETECTADO");
+  lines.push("═".repeat(60));
+
+  // Primary info
+  lines.push("");
+  lines.push(`  Linguagem: ${result.primary.language}`);
+  if (result.primary.runtime) lines.push(`  Runtime: ${result.primary.runtime}`);
+  if (result.primary.framework) lines.push(`  Framework: ${result.primary.framework}`);
+
+  // Ecosystems
+  if (result.ecosystems.length > 0) {
+    lines.push(`  Ecossistemas: ${result.ecosystems.join(", ")}`);
+  }
+
+  // Stack by category
+  const categories: [string, string[] | undefined][] = [
+    ["Frontend", result.stack.frontend],
+    ["Backend", result.stack.backend],
+    ["Database", result.stack.database],
+    ["ORM", result.stack.orm],
+    ["Styling", result.stack.styling],
+    ["Auth", result.stack.auth],
+    ["Testing", result.stack.testing],
+    ["DevOps", result.stack.devops],
+  ];
+
+  const hasStack = categories.some(([_, items]) => items && items.length > 0);
+  if (hasStack) {
+    lines.push("");
+    lines.push("─".repeat(60));
+    lines.push("TECNOLOGIAS");
+    lines.push("─".repeat(60));
+    lines.push("");
+
+    for (const [name, items] of categories) {
+      if (items && items.length > 0) {
+        lines.push(`  ${name}: ${items.join(", ")}`);
+      }
+    }
+  }
+
+  // Structure
+  if (Object.keys(result.structure).length > 0) {
+    lines.push("");
+    lines.push("─".repeat(60));
+    lines.push("ESTRUTURA");
+    lines.push("─".repeat(60));
+    lines.push("");
+
+    for (const [key, path] of Object.entries(result.structure)) {
+      lines.push(`  ${key}: ${path}/`);
+    }
+  }
+
+  // Config files
+  if (result.configFiles.length > 0) {
+    lines.push("");
+    lines.push("─".repeat(60));
+    lines.push("ARQUIVOS DE CONFIGURACAO");
+    lines.push("─".repeat(60));
+    lines.push("");
+
+    for (const file of result.configFiles.slice(0, 10)) {
+      lines.push(`  • ${file}`);
+    }
+    if (result.configFiles.length > 10) {
+      lines.push(`  ... e mais ${result.configFiles.length - 10} arquivos`);
+    }
+  }
+
+  lines.push("");
+  lines.push("─".repeat(60));
+
+  return lines.join("\n");
+}
+
+/**
+ * Get detailed technology list for JSON output
+ */
+export function getDetailedTechnologies(result: import("./index").UnifiedDetectionResult): {
+  category: string;
+  name: string;
+  version?: string;
+  confidence: number;
+  source: string;
+}[] {
+  return result.allTechnologies.map(t => ({
+    category: t.category,
+    name: t.name,
+    version: t.version,
+    confidence: t.confidence,
+    source: t.source,
+  }));
+}