feat: redesigne typing for more flexible

Author: tduyng

.gitignore

@@ -1 +1,2 @@
 codeme
+*_test.go

core/detector.go

@@ -1,53 +1,237 @@
 package core
 
 import (
-	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 )
 
-var langMap = map[string]string{
-	"go": "Go", "js": "JavaScript", "ts": "TypeScript", "py": "Python",
-	"rb": "Ruby", "java": "Java", "c": "C", "cpp": "C++", "cs": "C#",
-	"rs": "Rust", "php": "PHP", "swift": "Swift", "kt": "Kotlin",
-	"lua": "Lua", "vim": "Vim", "sh": "Shell", "bash": "Shell",
-	"md": "Markdown", "json": "JSON", "yaml": "YAML", "toml": "TOML",
-	"html": "HTML", "css": "CSS", "scss": "SCSS", "sql": "SQL",
+// LanguageDetector detects programming languages from file extensions
+type LanguageDetector struct {
+	extensionMap map[string]string
 }
 
-func DetectProject(filePath string) string {
-	// Try git root first
-	dir := filepath.Dir(filePath)
-	cmd := exec.Command("git", "rev-parse", "--show-toplevel")
-	cmd.Dir = dir
-	if output, err := cmd.Output(); err == nil {
-		return filepath.Base(strings.TrimSpace(string(output)))
+// NewLanguageDetector creates a new language detector
+func NewLanguageDetector() *LanguageDetector {
+	return &LanguageDetector{
+		extensionMap: map[string]string{
+			".go":      "Go",
+			".js":      "JavaScript",
+			".ts":      "TypeScript",
+			".jsx":     "React",
+			".tsx":     "React",
+			".py":      "Python",
+			".java":    "Java",
+			".c":       "C",
+			".cpp":     "C++",
+			".cc":      "C++",
+			".cxx":     "C++",
+			".h":       "C/C++",
+			".hpp":     "C++",
+			".cs":      "C#",
+			".php":     "PHP",
+			".rb":      "Ruby",
+			".rs":      "Rust",
+			".swift":   "Swift",
+			".kt":      "Kotlin",
+			".scala":   "Scala",
+			".r":       "R",
+			".m":       "Objective-C",
+			".mm":      "Objective-C++",
+			".sh":      "Shell",
+			".bash":    "Bash",
+			".zsh":     "Zsh",
+			".fish":    "Fish",
+			".pl":      "Perl",
+			".lua":     "Lua",
+			".vim":     "VimScript",
+			".el":      "Emacs Lisp",
+			".clj":     "Clojure",
+			".ex":      "Elixir",
+			".exs":     "Elixir",
+			".erl":     "Erlang",
+			".hs":      "Haskell",
+			".ml":      "OCaml",
+			".fs":      "F#",
+			".dart":    "Dart",
+			".vue":     "Vue",
+			".svelte":  "Svelte",
+			".html":    "HTML",
+			".htm":     "HTML",
+			".css":     "CSS",
+			".scss":    "SCSS",
+			".sass":    "Sass",
+			".less":    "Less",
+			".sql":     "SQL",
+			".json":    "JSON",
+			".xml":     "XML",
+			".yaml":    "YAML",
+			".yml":     "YAML",
+			".toml":    "TOML",
+			".md":      "Markdown",
+			".tex":     "LaTeX",
+			".proto":   "Protocol Buffer",
+			".graphql": "GraphQL",
+			".sol":     "Solidity",
+			".v":       "Verilog",
+			".vhd":     "VHDL",
+			".asm":     "Assembly",
+			".s":       "Assembly",
+		},
 	}
+}
+
+// DetectLanguage detects the programming language from a file path
+func (ld *LanguageDetector) DetectLanguage(filePath string) string {
+	ext := strings.ToLower(filepath.Ext(filePath))
 
-	// Fallback to directory name
-	abs, _ := filepath.Abs(filePath)
-	parts := strings.Split(filepath.Dir(abs), string(os.PathSeparator))
-	if len(parts) > 0 {
-		return parts[len(parts)-1]
+	if lang, ok := ld.extensionMap[ext]; ok {
+		return lang
 	}
-	return "unknown"
-}
 
-func DetectLanguage(filePath string) string {
-	ext := strings.TrimPrefix(filepath.Ext(filePath), ".")
-	if lang, ok := langMap[ext]; ok {
+	// Check for special cases without extensions
+	baseName := strings.ToLower(filepath.Base(filePath))
+
+	specialFiles := map[string]string{
+		"dockerfile":     "Docker",
+		"makefile":       "Make",
+		"justfile":       "Just",
+		"rakefile":       "Ruby",
+		"gemfile":        "Ruby",
+		"podfile":        "Ruby",
+		"vagrantfile":    "Ruby",
+		"cmakelists.txt": "CMake",
+		".gitignore":     "Git",
+		".dockerignore":  "Docker",
+		".editorconfig":  "EditorConfig",
+	}
+
+	if lang, ok := specialFiles[baseName]; ok {
 		return lang
 	}
-	return ext
+
+	return "Unknown"
+}
+
+// AddLanguageMapping adds a custom language mapping
+func (ld *LanguageDetector) AddLanguageMapping(extension, language string) {
+	if !strings.HasPrefix(extension, ".") {
+		extension = "." + extension
+	}
+	ld.extensionMap[strings.ToLower(extension)] = language
 }
 
-func DetectBranch(filePath string) string {
-	dir := filepath.Dir(filePath)
-	cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
-	cmd.Dir = dir
-	if output, err := cmd.Output(); err == nil {
-		return strings.TrimSpace(string(output))
+// ProjectDetector detects project information from file paths
+type ProjectDetector struct {
+	rootMarkers []string
+}
+
+// NewProjectDetector creates a new project detector
+func NewProjectDetector() *ProjectDetector {
+	return &ProjectDetector{
+		rootMarkers: []string{
+			".git",
+			"go.mod",
+			"package.json",
+			"pom.xml",
+			"build.gradle",
+			"Cargo.toml",
+			"requirements.txt",
+			"setup.py",
+			"composer.json",
+			"Gemfile",
+			".project",
+			"CMakeLists.txt",
+		},
 	}
-	return ""
+}
+
+// DetectProject extracts project name from file path
+func (pd *ProjectDetector) DetectProject(filePath string) string {
+	parts := strings.Split(filePath, string(filepath.Separator))
+
+	// Look for common project folder patterns
+	for i, part := range parts {
+		lower := strings.ToLower(part)
+		if lower == "src" || lower == "projects" || lower == "workspace" || lower == "repos" {
+			if i+1 < len(parts) {
+				return parts[i+1]
+			}
+		}
+	}
+
+	// Return the first non-root directory
+	for _, part := range parts {
+		if part != "" && part != "." && !strings.HasPrefix(part, ".") {
+			lower := strings.ToLower(part)
+			if lower != "users" && lower != "home" && lower != "documents" && lower != "desktop" {
+				return part
+			}
+		}
+	}
+
+	return "Unknown"
+}
+
+// AddRootMarker adds a custom project root marker
+func (pd *ProjectDetector) AddRootMarker(marker string) {
+	pd.rootMarkers = append(pd.rootMarkers, marker)
+}
+
+// EditorDetector detects the editor from process information
+type EditorDetector struct {
+	editorMap map[string]string
+}
+
+// NewEditorDetector creates a new editor detector
+func NewEditorDetector() *EditorDetector {
+	return &EditorDetector{
+		editorMap: map[string]string{
+			"vscode":        "VS Code",
+			"code":          "VS Code",
+			"sublime":       "Sublime Text",
+			"sublime_text":  "Sublime Text",
+			"atom":          "Atom",
+			"vim":           "Vim",
+			"nvim":          "Neovim",
+			"neovim":        "Neovim",
+			"emacs":         "Emacs",
+			"idea":          "IntelliJ IDEA",
+			"intellij":      "IntelliJ IDEA",
+			"pycharm":       "PyCharm",
+			"webstorm":      "WebStorm",
+			"goland":        "GoLand",
+			"clion":         "CLion",
+			"rider":         "Rider",
+			"androidstudio": "Android Studio",
+			"xcode":         "Xcode",
+			"eclipse":       "Eclipse",
+			"netbeans":      "NetBeans",
+			"notepad++":     "Notepad++",
+			"nano":          "Nano",
+			"gedit":         "gedit",
+			"kate":          "Kate",
+		},
+	}
+}
+
+// DetectEditor detects the editor from a process name
+func (ed *EditorDetector) DetectEditor(processName string) string {
+	lower := strings.ToLower(processName)
+
+	// Remove common extensions
+	lower = strings.TrimSuffix(lower, ".exe")
+	lower = strings.TrimSuffix(lower, ".app")
+
+	for key, editor := range ed.editorMap {
+		if strings.Contains(lower, key) {
+			return editor
+		}
+	}
+
+	return "Unknown"
+}
+
+// AddEditorMapping adds a custom editor mapping
+func (ed *EditorDetector) AddEditorMapping(processName, editor string) {
+	ed.editorMap[strings.ToLower(processName)] = editor
 }