@codexa/cli 8.5.0

package/detectors/flutter.ts

@@ -0,0 +1,351 @@
+/**
+ * Flutter/Dart Ecosystem Detector
+ *
+ * Detects Flutter and Dart projects including:
+ * - Flutter (Mobile, Web, Desktop)
+ * - Dart CLI/Server applications
+ * - State management: Riverpod, Bloc, Provider, GetX
+ * - Testing: flutter_test, mockito
+ */
+
+import { join } from "path";
+import {
+  registerDetector,
+  Detector,
+  DetectorResult,
+  DetectedTechnology,
+  fileExists,
+  dirExists,
+  findFiles,
+  readText,
+  parseYaml,
+} from "./index";
+
+interface PubspecYaml {
+  name?: string;
+  version?: string;
+  environment?: {
+    sdk?: string;
+    flutter?: string;
+  };
+  dependencies?: Record<string, any>;
+  dev_dependencies?: Record<string, any>;
+  flutter?: {
+    uses_material_design?: boolean;
+    assets?: string[];
+    fonts?: any[];
+  };
+}
+
+const flutterDetector: Detector = {
+  name: "flutter",
+  ecosystem: "flutter",
+  priority: 82,
+  markers: [
+    { type: "file", pattern: "pubspec.yaml", weight: 1.0 },
+    { type: "file", pattern: "pubspec.lock", weight: 0.9 },
+    { type: "file", pattern: ".flutter-plugins", weight: 0.8 },
+    { type: "file", pattern: ".flutter-plugins-dependencies", weight: 0.8 },
+    { type: "directory", pattern: "android", weight: 0.6 },
+    { type: "directory", pattern: "ios", weight: 0.6 },
+    { type: "directory", pattern: "lib", weight: 0.5 },
+    { type: "glob", pattern: "**/*.dart", weight: 0.7 },
+  ],
+
+  async detect(cwd: string): Promise<DetectorResult | null> {
+    const technologies: DetectedTechnology[] = [];
+    const structure: Record<string, string> = {};
+    const configFiles: string[] = [];
+
+    // Check for pubspec.yaml
+    const pubspecPath = join(cwd, "pubspec.yaml");
+    if (!fileExists(pubspecPath)) {
+      // Check for Dart files without pubspec
+      const dartFiles = findFiles(cwd, "**/*.dart");
+      if (dartFiles.length === 0) return null;
+
+      technologies.push({
+        name: "Dart",
+        confidence: 0.6,
+        source: "*.dart files (no pubspec)",
+        category: "runtime",
+      });
+
+      return { ecosystem: "flutter", technologies, structure, configFiles };
+    }
+
+    configFiles.push("pubspec.yaml");
+    if (fileExists(join(cwd, "pubspec.lock"))) configFiles.push("pubspec.lock");
+
+    const pubspecContent = readText(pubspecPath);
+    if (!pubspecContent) return null;
+
+    const pubspec = parseYaml(pubspecContent) as PubspecYaml;
+
+    // Collect all dependencies
+    const allDeps = new Map<string, any>();
+    const addDeps = (deps: Record<string, any> | undefined) => {
+      if (!deps) return;
+      for (const [name, value] of Object.entries(deps)) {
+        allDeps.set(name, value);
+      }
+    };
+
+    addDeps(pubspec.dependencies);
+    addDeps(pubspec.dev_dependencies);
+
+    // Detect if Flutter or pure Dart
+    const isFlutter = allDeps.has("flutter") || pubspec.flutter !== undefined;
+
+    if (isFlutter) {
+      technologies.push({
+        name: "Flutter",
+        version: pubspec.environment?.flutter,
+        confidence: 1.0,
+        source: "pubspec.yaml",
+        category: "frontend",
+      });
+
+      // Detect platforms
+      const platforms: string[] = [];
+      if (dirExists(join(cwd, "android"))) platforms.push("Android");
+      if (dirExists(join(cwd, "ios"))) platforms.push("iOS");
+      if (dirExists(join(cwd, "web"))) platforms.push("Web");
+      if (dirExists(join(cwd, "macos"))) platforms.push("macOS");
+      if (dirExists(join(cwd, "windows"))) platforms.push("Windows");
+      if (dirExists(join(cwd, "linux"))) platforms.push("Linux");
+
+      if (platforms.length > 0) {
+        technologies.push({
+          name: `Flutter (${platforms.join(", ")})`,
+          confidence: 0.95,
+          source: "Platform directories",
+          category: "frontend",
+          metadata: { platforms },
+        });
+      }
+    }
+
+    // Add Dart runtime
+    technologies.push({
+      name: "Dart",
+      version: pubspec.environment?.sdk,
+      confidence: 1.0,
+      source: "pubspec.yaml",
+      category: "runtime",
+    });
+
+    // State Management Detection
+    const stateManagement = [
+      { deps: ["flutter_riverpod", "riverpod", "hooks_riverpod"], name: "Riverpod", confidence: 1.0 },
+      { deps: ["flutter_bloc", "bloc"], name: "Bloc", confidence: 1.0 },
+      { deps: ["provider"], name: "Provider", confidence: 1.0 },
+      { deps: ["get", "get_it"], name: "GetX", confidence: 1.0 },
+      { deps: ["mobx", "flutter_mobx"], name: "MobX", confidence: 1.0 },
+      { deps: ["redux", "flutter_redux"], name: "Redux", confidence: 1.0 },
+      { deps: ["stacked"], name: "Stacked", confidence: 1.0 },
+    ];
+
+    for (const sm of stateManagement) {
+      const found = sm.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: sm.name,
+          confidence: sm.confidence,
+          source: `Dependency: ${found}`,
+          category: "frontend",
+          metadata: { type: "state-management" },
+        });
+      }
+    }
+
+    // Backend/API Libraries
+    const apiLibs = [
+      { deps: ["dio"], name: "Dio", confidence: 1.0 },
+      { deps: ["http"], name: "HTTP", confidence: 0.9 },
+      { deps: ["chopper"], name: "Chopper", confidence: 1.0 },
+      { deps: ["retrofit"], name: "Retrofit", confidence: 1.0 },
+      { deps: ["graphql_flutter", "graphql"], name: "GraphQL", confidence: 1.0 },
+    ];
+
+    for (const lib of apiLibs) {
+      const found = lib.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: lib.name,
+          confidence: lib.confidence,
+          source: `Dependency: ${found}`,
+          category: "backend",
+          metadata: { type: "http-client" },
+        });
+      }
+    }
+
+    // Database/Storage Detection
+    const databases = [
+      { deps: ["sqflite"], name: "SQFlite (SQLite)", confidence: 1.0 },
+      { deps: ["hive", "hive_flutter"], name: "Hive", confidence: 1.0 },
+      { deps: ["isar", "isar_flutter_libs"], name: "Isar", confidence: 1.0 },
+      { deps: ["moor", "drift"], name: "Drift (Moor)", confidence: 1.0 },
+      { deps: ["objectbox"], name: "ObjectBox", confidence: 1.0 },
+      { deps: ["shared_preferences"], name: "SharedPreferences", confidence: 0.9 },
+      { deps: ["firebase_core", "cloud_firestore"], name: "Firebase/Firestore", confidence: 1.0 },
+      { deps: ["supabase_flutter", "supabase"], name: "Supabase", confidence: 1.0 },
+      { deps: ["appwrite"], name: "Appwrite", confidence: 1.0 },
+    ];
+
+    const detectedDbs = new Set<string>();
+    for (const db of databases) {
+      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);
+      }
+    }
+
+    // Auth Detection
+    const authProviders = [
+      { deps: ["firebase_auth"], name: "Firebase Auth", confidence: 1.0 },
+      { deps: ["supabase_auth_ui"], name: "Supabase Auth", confidence: 1.0 },
+      { deps: ["google_sign_in"], name: "Google Sign-In", confidence: 0.9 },
+      { deps: ["sign_in_with_apple"], name: "Sign in with Apple", confidence: 0.9 },
+      { deps: ["flutter_facebook_auth"], name: "Facebook Auth", confidence: 0.9 },
+      { deps: ["flutter_appauth"], name: "AppAuth", confidence: 1.0 },
+    ];
+
+    for (const auth of authProviders) {
+      const found = auth.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: auth.name,
+          confidence: auth.confidence,
+          source: `Dependency: ${found}`,
+          category: "auth",
+        });
+      }
+    }
+
+    // Testing Detection
+    const testingTools = [
+      { deps: ["flutter_test"], name: "Flutter Test", confidence: 1.0 },
+      { deps: ["test"], name: "Dart Test", confidence: 0.95 },
+      { deps: ["mockito"], name: "Mockito", confidence: 0.95 },
+      { deps: ["mocktail"], name: "Mocktail", confidence: 0.95 },
+      { deps: ["bloc_test"], name: "Bloc Test", confidence: 0.95 },
+      { deps: ["golden_toolkit"], name: "Golden Toolkit", confidence: 0.9 },
+      { deps: ["integration_test"], name: "Integration Test", confidence: 0.95 },
+    ];
+
+    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",
+        });
+      }
+    }
+
+    // Navigation/Routing
+    const navigation = [
+      { deps: ["go_router"], name: "GoRouter", confidence: 1.0 },
+      { deps: ["auto_route"], name: "AutoRoute", confidence: 1.0 },
+      { deps: ["beamer"], name: "Beamer", confidence: 1.0 },
+      { deps: ["routemaster"], name: "Routemaster", confidence: 1.0 },
+    ];
+
+    for (const nav of navigation) {
+      const found = nav.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: nav.name,
+          confidence: nav.confidence,
+          source: `Dependency: ${found}`,
+          category: "frontend",
+          metadata: { type: "routing" },
+        });
+      }
+    }
+
+    // Code Generation
+    const codeGen = [
+      { deps: ["freezed", "freezed_annotation"], name: "Freezed", confidence: 1.0 },
+      { deps: ["json_serializable"], name: "JSON Serializable", confidence: 0.95 },
+      { deps: ["build_runner"], name: "Build Runner", confidence: 0.9 },
+      { deps: ["injectable"], name: "Injectable", confidence: 1.0 },
+    ];
+
+    for (const gen of codeGen) {
+      const found = gen.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: gen.name,
+          confidence: gen.confidence,
+          source: `Dependency: ${found}`,
+          category: "build",
+        });
+      }
+    }
+
+    // Structure detection
+    const structurePaths = [
+      { key: "lib", paths: ["lib"] },
+      { key: "screens", paths: ["lib/screens", "lib/pages", "lib/views", "lib/presentation/screens"] },
+      { key: "widgets", paths: ["lib/widgets", "lib/components", "lib/presentation/widgets"] },
+      { key: "models", paths: ["lib/models", "lib/domain/models", "lib/data/models"] },
+      { key: "services", paths: ["lib/services", "lib/data/services"] },
+      { key: "providers", paths: ["lib/providers", "lib/riverpod", "lib/blocs"] },
+      { key: "repositories", paths: ["lib/repositories", "lib/data/repositories"] },
+      { key: "utils", paths: ["lib/utils", "lib/helpers", "lib/core/utils"] },
+      { key: "config", paths: ["lib/config", "lib/core/config"] },
+      { key: "test", paths: ["test"] },
+      { key: "integration_test", paths: ["integration_test"] },
+    ];
+
+    for (const { key, paths } of structurePaths) {
+      for (const p of paths) {
+        if (dirExists(join(cwd, p))) {
+          structure[key] = p;
+          break;
+        }
+      }
+    }
+
+    // Config files
+    const configPatterns = [
+      "analysis_options.yaml",
+      ".dart_tool/package_config.json",
+      "build.yaml",
+      "melos.yaml",
+      "firebase.json",
+      ".firebaserc",
+      "Podfile",
+      "android/build.gradle",
+    ];
+
+    for (const pattern of configPatterns) {
+      if (fileExists(join(cwd, pattern))) {
+        configFiles.push(pattern);
+      }
+    }
+
+    return {
+      ecosystem: "flutter",
+      technologies,
+      structure,
+      configFiles: [...new Set(configFiles)],
+    };
+  },
+};
+
+// Register the detector
+registerDetector(flutterDetector);
+
+export default flutterDetector;

package/detectors/go.ts

@@ -0,0 +1,325 @@
+/**
+ * Go Ecosystem Detector
+ *
+ * Detects Go projects including:
+ * - Frameworks: Gin, Echo, Fiber, Chi, net/http
+ * - ORMs: GORM, Ent, SQLx, SQLC
+ * - Testing: built-in testing, testify, gomega
+ */
+
+import { join } from "path";
+import {
+  registerDetector,
+  Detector,
+  DetectorResult,
+  DetectedTechnology,
+  fileExists,
+  dirExists,
+  findFiles,
+  readText,
+} from "./index";
+
+interface GoMod {
+  module: string;
+  goVersion?: string;
+  require: { path: string; version: string }[];
+}
+
+function parseGoMod(content: string): GoMod {
+  const result: GoMod = { module: "", require: [] };
+
+  const moduleMatch = content.match(/^module\s+(.+)$/m);
+  if (moduleMatch) result.module = moduleMatch[1].trim();
+
+  const goMatch = content.match(/^go\s+(\d+\.\d+(?:\.\d+)?)$/m);
+  if (goMatch) result.goVersion = goMatch[1];
+
+  // Parse require block
+  const requireBlockMatch = content.match(/require\s*\(([\s\S]*?)\)/);
+  if (requireBlockMatch) {
+    const requireLines = requireBlockMatch[1].split("\n");
+    for (const line of requireLines) {
+      const match = line.trim().match(/^([^\s]+)\s+([^\s]+)/);
+      if (match && !match[0].startsWith("//")) {
+        result.require.push({ path: match[1], version: match[2] });
+      }
+    }
+  }
+
+  // Parse single-line requires
+  const singleRequires = content.matchAll(/^require\s+([^\s]+)\s+([^\s]+)$/gm);
+  for (const match of singleRequires) {
+    result.require.push({ path: match[1], version: match[2] });
+  }
+
+  return result;
+}
+
+const goDetector: Detector = {
+  name: "go",
+  ecosystem: "go",
+  priority: 80,
+  markers: [
+    { type: "file", pattern: "go.mod", weight: 1.0 },
+    { type: "file", pattern: "go.sum", weight: 0.9 },
+    { type: "file", pattern: "go.work", weight: 0.9 },
+    { type: "glob", pattern: "**/*.go", weight: 0.7 },
+    { type: "directory", pattern: "cmd", weight: 0.6 },
+    { type: "directory", pattern: "pkg", weight: 0.5 },
+    { type: "directory", pattern: "internal", weight: 0.5 },
+  ],
+
+  async detect(cwd: string): Promise<DetectorResult | null> {
+    const technologies: DetectedTechnology[] = [];
+    const structure: Record<string, string> = {};
+    const configFiles: string[] = [];
+
+    // Check for go.mod
+    const goModPath = join(cwd, "go.mod");
+    if (!fileExists(goModPath)) {
+      // Check for Go files without go.mod (legacy GOPATH)
+      const goFiles = findFiles(cwd, "**/*.go");
+      if (goFiles.length === 0) return null;
+
+      technologies.push({
+        name: "Go",
+        confidence: 0.7,
+        source: "*.go files (no go.mod)",
+        category: "runtime",
+      });
+
+      return { ecosystem: "go", technologies, structure, configFiles };
+    }
+
+    configFiles.push("go.mod");
+    if (fileExists(join(cwd, "go.sum"))) configFiles.push("go.sum");
+    if (fileExists(join(cwd, "go.work"))) {
+      configFiles.push("go.work");
+      technologies.push({
+        name: "Go Workspaces",
+        confidence: 1.0,
+        source: "go.work",
+        category: "build",
+      });
+    }
+
+    const goModContent = readText(goModPath);
+    if (!goModContent) return null;
+
+    const goMod = parseGoMod(goModContent);
+
+    // Add Go runtime
+    technologies.push({
+      name: "Go",
+      version: goMod.goVersion,
+      confidence: 1.0,
+      source: "go.mod",
+      category: "runtime",
+    });
+
+    // Create dependency lookup
+    const deps = new Map<string, string>();
+    for (const req of goMod.require) {
+      deps.set(req.path, req.version);
+    }
+
+    // Web Framework Detection
+    const webFrameworks = [
+      { paths: ["github.com/gin-gonic/gin"], name: "Gin", confidence: 1.0 },
+      { paths: ["github.com/labstack/echo/v4", "github.com/labstack/echo"], name: "Echo", confidence: 1.0 },
+      { paths: ["github.com/gofiber/fiber/v2", "github.com/gofiber/fiber"], name: "Fiber", confidence: 1.0 },
+      { paths: ["github.com/go-chi/chi/v5", "github.com/go-chi/chi"], name: "Chi", confidence: 1.0 },
+      { paths: ["github.com/gorilla/mux"], name: "Gorilla Mux", confidence: 0.95 },
+      { paths: ["github.com/beego/beego/v2", "github.com/astaxie/beego"], name: "Beego", confidence: 1.0 },
+      { paths: ["github.com/kataras/iris/v12", "github.com/kataras/iris"], name: "Iris", confidence: 1.0 },
+      { paths: ["github.com/revel/revel"], name: "Revel", confidence: 1.0 },
+      { paths: ["github.com/valyala/fasthttp"], name: "FastHTTP", confidence: 0.9 },
+      { paths: ["github.com/cloudwego/hertz"], name: "Hertz", confidence: 1.0 },
+    ];
+
+    for (const fw of webFrameworks) {
+      const found = fw.paths.find(p => deps.has(p));
+      if (found) {
+        technologies.push({
+          name: fw.name,
+          version: deps.get(found),
+          confidence: fw.confidence,
+          source: `Dependency: ${found}`,
+          category: "backend",
+        });
+      }
+    }
+
+    // ORM/Database Library Detection
+    const orms = [
+      { paths: ["gorm.io/gorm", "github.com/jinzhu/gorm"], name: "GORM", confidence: 1.0 },
+      { paths: ["entgo.io/ent"], name: "Ent", confidence: 1.0 },
+      { paths: ["github.com/jmoiron/sqlx"], name: "SQLx", confidence: 1.0 },
+      { paths: ["github.com/kyleconroy/sqlc", "github.com/sqlc-dev/sqlc"], name: "SQLC", confidence: 1.0 },
+      { paths: ["github.com/uptrace/bun"], name: "Bun", confidence: 1.0 },
+      { paths: ["xorm.io/xorm"], name: "XORM", confidence: 1.0 },
+      { paths: ["github.com/doug-martin/goqu/v9"], name: "goqu", confidence: 0.95 },
+    ];
+
+    for (const orm of orms) {
+      const found = orm.paths.find(p => deps.has(p));
+      if (found) {
+        technologies.push({
+          name: orm.name,
+          version: deps.get(found),
+          confidence: orm.confidence,
+          source: `Dependency: ${found}`,
+          category: "orm",
+        });
+      }
+    }
+
+    // Database Drivers
+    const dbDrivers = [
+      { paths: ["github.com/lib/pq", "github.com/jackc/pgx/v5", "github.com/jackc/pgx/v4"], name: "PostgreSQL", confidence: 0.9 },
+      { paths: ["github.com/go-sql-driver/mysql"], name: "MySQL", confidence: 0.9 },
+      { paths: ["github.com/mattn/go-sqlite3", "modernc.org/sqlite"], name: "SQLite", confidence: 0.9 },
+      { paths: ["go.mongodb.org/mongo-driver/mongo"], name: "MongoDB", confidence: 0.9 },
+      { paths: ["github.com/redis/go-redis/v9", "github.com/go-redis/redis/v8"], name: "Redis", confidence: 0.9 },
+      { paths: ["github.com/elastic/go-elasticsearch/v8"], name: "Elasticsearch", confidence: 0.9 },
+      { paths: ["github.com/gocql/gocql"], name: "Cassandra", confidence: 0.9 },
+    ];
+
+    const detectedDbs = new Set<string>();
+    for (const db of dbDrivers) {
+      const found = db.paths.find(p => deps.has(p));
+      if (found && !detectedDbs.has(db.name)) {
+        technologies.push({
+          name: db.name,
+          confidence: db.confidence,
+          source: `Dependency: ${found}`,
+          category: "database",
+        });
+        detectedDbs.add(db.name);
+      }
+    }
+
+    // Testing Tools
+    const testingTools = [
+      { paths: ["github.com/stretchr/testify"], name: "Testify", confidence: 1.0 },
+      { paths: ["github.com/onsi/ginkgo/v2", "github.com/onsi/ginkgo"], name: "Ginkgo", confidence: 1.0 },
+      { paths: ["github.com/onsi/gomega"], name: "Gomega", confidence: 0.95 },
+      { paths: ["github.com/golang/mock/gomock"], name: "GoMock", confidence: 1.0 },
+      { paths: ["github.com/DATA-DOG/go-sqlmock"], name: "SQLMock", confidence: 0.9 },
+    ];
+
+    for (const test of testingTools) {
+      const found = test.paths.find(p => deps.has(p));
+      if (found) {
+        technologies.push({
+          name: test.name,
+          version: deps.get(found),
+          confidence: test.confidence,
+          source: `Dependency: ${found}`,
+          category: "testing",
+        });
+      }
+    }
+
+    // Auth/Security
+    const authTools = [
+      { paths: ["github.com/golang-jwt/jwt/v5", "github.com/dgrijalva/jwt-go"], name: "JWT-Go", confidence: 0.9 },
+      { paths: ["github.com/casbin/casbin/v2"], name: "Casbin", confidence: 1.0 },
+      { paths: ["golang.org/x/oauth2"], name: "OAuth2", confidence: 0.9 },
+    ];
+
+    for (const auth of authTools) {
+      const found = auth.paths.find(p => deps.has(p));
+      if (found) {
+        technologies.push({
+          name: auth.name,
+          confidence: auth.confidence,
+          source: `Dependency: ${found}`,
+          category: "auth",
+        });
+      }
+    }
+
+    // DevOps/Infrastructure
+    const devopsTools = [
+      { paths: ["github.com/spf13/cobra"], name: "Cobra CLI", confidence: 0.9 },
+      { paths: ["github.com/spf13/viper"], name: "Viper Config", confidence: 0.9 },
+      { paths: ["go.uber.org/zap"], name: "Zap Logger", confidence: 0.9 },
+      { paths: ["github.com/sirupsen/logrus"], name: "Logrus", confidence: 0.9 },
+      { paths: ["github.com/prometheus/client_golang"], name: "Prometheus", confidence: 0.9 },
+      { paths: ["go.opentelemetry.io/otel"], name: "OpenTelemetry", confidence: 0.9 },
+    ];
+
+    for (const tool of devopsTools) {
+      const found = tool.paths.find(p => deps.has(p));
+      if (found) {
+        technologies.push({
+          name: tool.name,
+          confidence: tool.confidence,
+          source: `Dependency: ${found}`,
+          category: "devops",
+        });
+      }
+    }
+
+    // Structure detection (standard Go project layout)
+    const structurePaths = [
+      { key: "cmd", paths: ["cmd"] },
+      { key: "internal", paths: ["internal"] },
+      { key: "pkg", paths: ["pkg"] },
+      { key: "api", paths: ["api", "internal/api", "pkg/api"] },
+      { key: "handlers", paths: ["internal/handlers", "handlers", "pkg/handlers"] },
+      { key: "services", paths: ["internal/services", "services", "pkg/services"] },
+      { key: "models", paths: ["internal/models", "models", "pkg/models", "internal/domain"] },
+      { key: "repository", paths: ["internal/repository", "repository", "internal/db"] },
+      { key: "config", paths: ["config", "internal/config", "configs"] },
+      { key: "migrations", paths: ["migrations", "db/migrations", "internal/db/migrations"] },
+      { key: "tests", paths: ["tests", "test"] },
+      { key: "scripts", paths: ["scripts"] },
+      { key: "docs", paths: ["docs"] },
+    ];
+
+    for (const { key, paths } of structurePaths) {
+      for (const p of paths) {
+        if (dirExists(join(cwd, p))) {
+          structure[key] = p;
+          break;
+        }
+      }
+    }
+
+    // Config files
+    const configPatterns = [
+      ".golangci.yml",
+      ".golangci.yaml",
+      "Makefile",
+      "air.toml",
+      ".air.toml",
+      "sqlc.yaml",
+      "sqlc.yml",
+      ".goreleaser.yml",
+      ".goreleaser.yaml",
+      "Dockerfile",
+      "docker-compose.yml",
+      "docker-compose.yaml",
+    ];
+
+    for (const pattern of configPatterns) {
+      if (fileExists(join(cwd, pattern))) {
+        configFiles.push(pattern);
+      }
+    }
+
+    return {
+      ecosystem: "go",
+      technologies,
+      structure,
+      configFiles: [...new Set(configFiles)],
+    };
+  },
+};
+
+// Register the detector
+registerDetector(goDetector);
+
+export default goDetector;