Example AI generated Go code using Cursor rules

langdetect.go

// originally at internal/langdetect/langdetect.go
package langdetect

import (
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
)

// Language represents a programming language
type Language int

const (
	Unknown Language = iota
	Go
	Python
	JavaScript // Now represents both JavaScript and TypeScript
	Ruby
	Java
	Kotlin
	Swift
	Rust
	CPP
	CSharp
	PHP
	Scala
	Haskell
	Elixir
	Erlang
	Clojure
	R
	Julia
	Dart
	Lua
	Perl
	OCaml
	Groovy
	Shell
)

// Framework represents all supported frameworks across languages
type Framework int

const (
	NoFramework Framework = iota

	// JavaScript/TypeScript Frameworks
	ReactFramework
	VueFramework
	AngularFramework
	SvelteFramework
	NextJSFramework
	NuxtJSFramework
	ExpressFramework
	NestJSFramework
	GatsbyFramework
	RemixFramework

	// Python Frameworks
	DjangoFramework
	FlaskFramework
	FastAPIFramework
	PyramidFramework

	// Go Frameworks
	GinFramework
	EchoFramework
	FiberFramework

	// Ruby Frameworks
	RailsFramework
	SinatraFramework

	// Java Frameworks
	SpringFramework
	QuarkusFramework
	MicronautFramework
)

// JSVariant represents whether the project uses JavaScript or TypeScript
type JSVariant int

const (
	UnknownVariant JSVariant = iota
	JavaScriptVariant
	TypeScriptVariant
)

// FrameworkMetadata contains information about a framework
type FrameworkMetadata struct {
	Name            string
	SupportedLangs  []Language
	DetectionFiles  []string // Files that indicate the framework's presence
	DetectionString string   // String to search for in dependency files
	Category        string   // e.g., "Web", "Mobile", "Data Science"
}

// frameworkMetadata maps Framework constants to their metadata
var frameworkMetadata = map[Framework]FrameworkMetadata{
	ReactFramework: {
		Name:            "React",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "react",
		Category:        "Web",
	},
	VueFramework: {
		Name:            "Vue",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "vue",
		Category:        "Web",
	},
	AngularFramework: {
		Name:            "Angular",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "@angular/core",
		Category:        "Web",
	},
	SvelteFramework: {
		Name:            "Svelte",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "svelte",
		Category:        "Web",
	},
	NextJSFramework: {
		Name:            "Next.js",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "next",
		Category:        "Web",
	},
	NuxtJSFramework: {
		Name:            "Nuxt.js",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "nuxt",
		Category:        "Web",
	},
	ExpressFramework: {
		Name:            "Express",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "express",
		Category:        "Web",
	},
	NestJSFramework: {
		Name:            "NestJS",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "@nestjs/core",
		Category:        "Web",
	},
	GatsbyFramework: {
		Name:            "Gatsby",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "gatsby",
		Category:        "Web",
	},
	RemixFramework: {
		Name:            "Remix",
		SupportedLangs:  []Language{JavaScript},
		DetectionString: "remix",
		Category:        "Web",
	},
	DjangoFramework: {
		Name:           "Django",
		SupportedLangs: []Language{Python},
		DetectionFiles: []string{"manage.py"},
		Category:       "Web",
	},
	FlaskFramework: {
		Name:            "Flask",
		SupportedLangs:  []Language{Python},
		DetectionString: "flask",
		Category:        "Web",
	},
	FastAPIFramework: {
		Name:            "FastAPI",
		SupportedLangs:  []Language{Python},
		DetectionString: "fastapi",
		Category:        "Web",
	},
	PyramidFramework: {
		Name:            "Pyramid",
		SupportedLangs:  []Language{Python},
		DetectionString: "pyramid",
		Category:        "Web",
	},
	GinFramework: {
		Name:            "Gin",
		SupportedLangs:  []Language{Go},
		DetectionString: "github.com/gin-gonic/gin",
		Category:        "Web",
	},
	EchoFramework: {
		Name:            "Echo",
		SupportedLangs:  []Language{Go},
		DetectionString: "github.com/labstack/echo",
		Category:        "Web",
	},
	FiberFramework: {
		Name:            "Fiber",
		SupportedLangs:  []Language{Go},
		DetectionString: "github.com/gofiber/fiber",
		Category:        "Web",
	},
	RailsFramework: {
		Name:            "Ruby on Rails",
		SupportedLangs:  []Language{Ruby},
		DetectionString: "gem 'rails'",
		Category:        "Web",
	},
	SinatraFramework: {
		Name:            "Sinatra",
		SupportedLangs:  []Language{Ruby},
		DetectionString: "gem 'sinatra'",
		Category:        "Web",
	},
	SpringFramework: {
		Name:            "Spring",
		SupportedLangs:  []Language{Java},
		DetectionString: "org.springframework.boot",
		Category:        "Web",
	},
	QuarkusFramework: {
		Name:            "Quarkus",
		SupportedLangs:  []Language{Java},
		DetectionString: "io.quarkus",
		Category:        "Web",
	},
	MicronautFramework: {
		Name:            "Micronaut",
		SupportedLangs:  []Language{Java},
		DetectionString: "io.micronaut",
		Category:        "Web",
	},
}

// String returns the string representation of the JSVariant
func (v JSVariant) String() string {
	return [...]string{
		"Unknown",
		"JavaScript",
		"TypeScript",
	}[v]
}

// String returns the string representation of the Language
func (l Language) String() string {
	return [...]string{
		"Unknown",
		"Go",
		"Python",
		"JavaScript/TypeScript",
		"Ruby",
		"Java",
		"Kotlin",
		"Swift",
		"Rust",
		"C++",
		"C#",
		"PHP",
		"Scala",
		"Haskell",
		"Elixir",
		"Erlang",
		"Clojure",
		"R",
		"Julia",
		"Dart",
		"Lua",
		"Perl",
		"OCaml",
		"Groovy",
		"Shell",
	}[l]
}

// String returns the string representation of the Framework
func (f Framework) String() string {
	if meta, ok := frameworkMetadata[f]; ok {
		return meta.Name
	}
	return "Unknown Framework"
}

// ProjectInfo contains detailed information about a project
type ProjectInfo struct {
	Language  Language
	Framework Framework
	JSVariant JSVariant // Only relevant for JavaScript/TypeScript projects
}

type filePattern struct {
	pattern   string
	language  Language
	isProject bool
}

func StringToLanguage(s string) Language {
	switch strings.ToLower(s) {
	case "go":
		return Go
	case "javascript", "typescript":
		return JavaScript
	case "python":
		return Python
	case "ruby":
		return Ruby
	case "java":
		return Java
	case "kotlin":
		return Kotlin
	case "swift":
		return Swift
	case "rust":
		return Rust
	case "c++":
		return CPP
	case "c#":
		return CSharp
	case "php":
		return PHP
	case "scala":
		return Scala
	case "haskell":
		return Haskell
	case "elixir":
		return Elixir
	case "erlang":
		return Erlang
	case "clojure":
		return Clojure
	case "r":
		return R
	case "julia":
		return Julia
	case "dart":
		return Dart
	case "lua":
		return Lua
	case "perl":
		return Perl
	case "ocaml":
		return OCaml
	case "groovy":
		return Groovy
	case "shell":
		return Shell
	}
	return Unknown
}

var patterns = []filePattern{
	// Project files (stronger indicators)
	{pattern: "go.mod", language: Go, isProject: true},
	{pattern: "package.json", language: JavaScript, isProject: true},
	{pattern: "tsconfig.json", language: JavaScript, isProject: true},
	{pattern: "Gemfile", language: Ruby, isProject: true},
	{pattern: "pom.xml", language: Java, isProject: true},
	{pattern: "build.gradle", language: Java, isProject: true},
	{pattern: "build.gradle.kts", language: Kotlin, isProject: true},
	{pattern: "Package.swift", language: Swift, isProject: true},
	{pattern: "Cargo.toml", language: Rust, isProject: true},
	{pattern: "CMakeLists.txt", language: CPP, isProject: true},
	{pattern: ".csproj", language: CSharp, isProject: true},
	{pattern: "composer.json", language: PHP, isProject: true},
	{pattern: "build.sbt", language: Scala, isProject: true},
	{pattern: "stack.yaml", language: Haskell, isProject: true},
	{pattern: "mix.exs", language: Elixir, isProject: true},
	{pattern: "rebar.config", language: Erlang, isProject: true},
	{pattern: "project.clj", language: Clojure, isProject: true},
	{pattern: "DESCRIPTION", language: R, isProject: true},
	{pattern: "Project.toml", language: Julia, isProject: true},
	{pattern: "pubspec.yaml", language: Dart, isProject: true},
	{pattern: "requirements.txt", language: Python, isProject: true},
	{pattern: "pyproject.toml", language: Python, isProject: true},
	{pattern: "Pipfile", language: Python, isProject: true},
	{pattern: "Pipfile.lock", language: Python, isProject: true},
	{pattern: "requirements.lock", language: Python, isProject: true},
	{pattern: "uv.lock", language: Python, isProject: true},

	// Source files (weaker indicators)
	{pattern: ".go", language: Go},
	{pattern: ".py", language: Python},
	{pattern: ".js", language: JavaScript},
	{pattern: ".ts", language: JavaScript},
	{pattern: ".jsx", language: JavaScript},
	{pattern: ".tsx", language: JavaScript},
	{pattern: ".rb", language: Ruby},
	{pattern: ".java", language: Java},
	{pattern: ".kt", language: Kotlin},
	{pattern: ".swift", language: Swift},
	{pattern: ".rs", language: Rust},
	{pattern: ".cpp", language: CPP},
	{pattern: ".cc", language: CPP},
	{pattern: ".cs", language: CSharp},
	{pattern: ".php", language: PHP},
	{pattern: ".scala", language: Scala},
	{pattern: ".hs", language: Haskell},
	{pattern: ".ex", language: Elixir},
	{pattern: ".exs", language: Elixir},
	{pattern: ".erl", language: Erlang},
	{pattern: ".clj", language: Clojure},
	{pattern: ".R", language: R},
	{pattern: ".jl", language: Julia},
	{pattern: ".dart", language: Dart},
	{pattern: ".lua", language: Lua},
	{pattern: ".pl", language: Perl},
	{pattern: ".ml", language: OCaml},
	{pattern: ".groovy", language: Groovy},
	{pattern: ".sh", language: Shell},
	{pattern: ".bash", language: Shell},
}

// DetectProjectLanguage attempts to determine the primary programming language
// used in a project given its root directory path.
func DetectProjectLanguage(projectPath string) Language {
	type langScore struct {
		lang  Language
		score int
	}
	scores := make(map[Language]*langScore)

	// Walk through the project directory
	err := filepath.Walk(projectPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil // Skip files we can't access
		}

		// Skip hidden directories and files
		if strings.HasPrefix(info.Name(), ".") && info.Name() != ".go.mod" {
			if info.IsDir() {
				return filepath.SkipDir
			}
			return nil
		}

		// Skip vendor and node_modules directories
		if info.IsDir() && (info.Name() == "vendor" || info.Name() == "node_modules") {
			return filepath.SkipDir
		}

		for _, pattern := range patterns {
			matches := false
			if pattern.isProject {
				matches = info.Name() == pattern.pattern
			} else {
				matches = strings.HasSuffix(strings.ToLower(info.Name()), pattern.pattern)
			}

			if matches {
				if _, exists := scores[pattern.language]; !exists {
					scores[pattern.language] = &langScore{lang: pattern.language}
				}

				// Project files are stronger indicators
				if pattern.isProject {
					scores[pattern.language].score += 100
				} else {
					scores[pattern.language].score++
				}
			}
		}
		return nil
	})

	if err != nil {
		return Unknown
	}

	// Find the language with the highest score
	var highestScore int
	var detectedLang Language = Unknown

	for _, score := range scores {
		if score.score > highestScore {
			highestScore = score.score
			detectedLang = score.lang
		}
	}

	return detectedLang
}

// DetectJSVariant determines if a JavaScript project uses TypeScript
func DetectJSVariant(projectPath string) JSVariant {
	// Check for TypeScript
	tsConfigPath := filepath.Join(projectPath, "tsconfig.json")
	if _, err := os.Stat(tsConfigPath); err == nil {
		return TypeScriptVariant
	}

	// Look for .ts or .tsx files
	err := filepath.Walk(projectPath, func(path string, f os.FileInfo, err error) error {
		if err != nil {
			return nil
		}
		if !f.IsDir() && (strings.HasSuffix(f.Name(), ".ts") || strings.HasSuffix(f.Name(), ".tsx")) {
			return filepath.SkipDir
		}
		return nil
	})

	if err == nil {
		return JavaScriptVariant
	}

	return UnknownVariant
}

// DetectJSInfo analyzes a JavaScript/TypeScript project to determine its variant and framework
func DetectJSInfo(projectPath string) ProjectInfo {
	info := ProjectInfo{
		Language:  JavaScript,
		Framework: NoFramework,
		JSVariant: DetectJSVariant(projectPath),
	}

	// Read package.json to detect framework
	packageJSONPath := filepath.Join(projectPath, "package.json")
	if packageData, err := os.ReadFile(packageJSONPath); err == nil {
		var pkg struct {
			Dependencies    map[string]string `json:"dependencies"`
			DevDependencies map[string]string `json:"devDependencies"`
		}
		if err := json.Unmarshal(packageData, &pkg); err == nil {
			deps := make(map[string]struct{})
			for k := range pkg.Dependencies {
				deps[k] = struct{}{}
			}
			for k := range pkg.DevDependencies {
				deps[k] = struct{}{}
			}

			// Check for frameworks in order of specificity
			switch {
			case hasAny(deps, "next"):
				info.Framework = NextJSFramework
			case hasAny(deps, "nuxt"):
				info.Framework = NuxtJSFramework
			case hasAny(deps, "gatsby"):
				info.Framework = GatsbyFramework
			case hasAny(deps, "remix"):
				info.Framework = RemixFramework
			case hasAny(deps, "@nestjs/core"):
				info.Framework = NestJSFramework
			case hasAny(deps, "express"):
				info.Framework = ExpressFramework
			case hasAny(deps, "@angular/core"):
				info.Framework = AngularFramework
			case hasAny(deps, "svelte"):
				info.Framework = SvelteFramework
			case hasAny(deps, "vue"):
				info.Framework = VueFramework
			case hasAny(deps, "react", "react-dom"):
				info.Framework = ReactFramework
			}
		}
	}

	return info
}

// hasAny checks if any of the given dependencies exist in the deps map
func hasAny(deps map[string]struct{}, names ...string) bool {
	for _, name := range names {
		if _, exists := deps[name]; exists {
			return true
		}
	}
	return false
}

// GetFrameworksForLanguage returns all frameworks that support the given language
func GetFrameworksForLanguage(lang Language) []Framework {
	var frameworks []Framework
	for framework, meta := range frameworkMetadata {
		for _, supportedLang := range meta.SupportedLangs {
			if supportedLang == lang {
				frameworks = append(frameworks, framework)
				break
			}
		}
	}
	return frameworks
}

// DetectFramework attempts to determine the framework used in a project
func DetectFramework(projectPath string, lang Language) Framework {
	// Get all frameworks that support this language
	possibleFrameworks := GetFrameworksForLanguage(lang)

	// Special handling for JavaScript/TypeScript
	if lang == JavaScript {
		jsInfo := DetectJSInfo(projectPath)
		return jsInfo.Framework
	}

	for _, framework := range possibleFrameworks {
		meta := frameworkMetadata[framework]

		// Check for framework-specific files
		if len(meta.DetectionFiles) > 0 {
			for _, file := range meta.DetectionFiles {
				if hasFile(projectPath, file) {
					return framework
				}
			}
		}

		// Check dependency files based on language
		switch lang {
		case Python:
			if detectPythonDependency(projectPath, meta.DetectionString) {
				return framework
			}
		case Go:
			if detectGoDependency(projectPath, meta.DetectionString) {
				return framework
			}
		case Ruby:
			if detectRubyDependency(projectPath, meta.DetectionString) {
				return framework
			}
		case Java:
			if detectJavaDependency(projectPath, meta.DetectionString) {
				return framework
			}
		}
	}

	return NoFramework
}

func detectJSDependency(projectPath, dependency string) bool {
	packageJSONPath := filepath.Join(projectPath, "package.json")
	if packageData, err := os.ReadFile(packageJSONPath); err == nil {
		var pkg struct {
			Dependencies    map[string]string `json:"dependencies"`
			DevDependencies map[string]string `json:"devDependencies"`
		}
		if err := json.Unmarshal(packageData, &pkg); err == nil {
			deps := make(map[string]struct{})
			for k := range pkg.Dependencies {
				deps[k] = struct{}{}
			}
			for k := range pkg.DevDependencies {
				deps[k] = struct{}{}
			}
			return hasAny(deps, dependency)
		}
	}
	return false
}

func detectPythonDependency(projectPath, dependency string) bool {
	files := []string{
		filepath.Join(projectPath, "requirements.txt"),
		filepath.Join(projectPath, "Pipfile"),
		filepath.Join(projectPath, "pyproject.toml"),
	}

	for _, file := range files {
		if data, err := os.ReadFile(file); err == nil {
			if strings.Contains(string(data), dependency) {
				return true
			}
		}
	}
	return false
}

func detectGoDependency(projectPath, dependency string) bool {
	modFile := filepath.Join(projectPath, "go.mod")
	if data, err := os.ReadFile(modFile); err == nil {
		return strings.Contains(string(data), dependency)
	}
	return false
}

func detectRubyDependency(projectPath, dependency string) bool {
	gemfile := filepath.Join(projectPath, "Gemfile")
	if data, err := os.ReadFile(gemfile); err == nil {
		return strings.Contains(string(data), dependency)
	}
	return false
}

func detectJavaDependency(projectPath, dependency string) bool {
	files := []string{
		filepath.Join(projectPath, "pom.xml"),
		filepath.Join(projectPath, "build.gradle"),
	}

	for _, file := range files {
		if data, err := os.ReadFile(file); err == nil {
			if strings.Contains(string(data), dependency) {
				return true
			}
		}
	}
	return false
}

// Helper function to check if a file exists
func hasFile(dir, filename string) bool {
	_, err := os.Stat(filepath.Join(dir, filename))
	return err == nil
}