feat: add Go language support

This implementation adds comprehensive Go language support to gittype as part of issue #55.

Changes include:
- Added tree-sitter-go dependency for Go AST parsing
- Extended Language enum to include Go
- Implemented Go-specific code extraction for:
  - Functions (func declarations)
  - Methods (with receiver syntax)
  - Structs (type declarations with struct_type)
  - Interfaces (type declarations with interface_type)
- Added Go file extension mapping (.go files)
- Added Interface chunk type for Go interfaces
- Enhanced name extraction to support field_identifier nodes
- Added comprehensive test coverage for all Go language features

All existing tests continue to pass, ensuring backward compatibility.

Resolves #55

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

Cargo.lock

@@ -25,6 +25,7 @@ tree-sitter-rust = "0.20"
 tree-sitter-typescript = "0.20"
 tree-sitter-python = "0.20"
 tree-sitter-ruby = "0.20"
+tree-sitter-go = "0.20"
 crossterm = "0.27"
 ratatui = "0.26"
 rusqlite = { version = "0.29", features = ["bundled"] }

Cargo.toml

@@ -346,6 +346,7 @@ impl ChallengeConverter {
             super::Language::TypeScript => "typescript".to_string(),
             super::Language::Python => "python".to_string(),
             super::Language::Ruby => "ruby".to_string(),
+            super::Language::Go => "go".to_string(),
         }
     }
 }

src/extractor/challenge_converter.rs

@@ -7,6 +7,7 @@ pub enum ChunkType {
     Class,
     Method,
     Struct,
+    Interface,
     Module,
 }
 

src/extractor/chunk.rs

@@ -4,6 +4,7 @@ pub enum Language {
     TypeScript,
     Python,
     Ruby,
+    Go,
 }
 
 impl Language {
@@ -13,6 +14,7 @@ impl Language {
             "ts" | "tsx" => Some(Language::TypeScript),
             "py" => Some(Language::Python),
             "rb" => Some(Language::Ruby),
+            "go" => Some(Language::Go),
             _ => None,
         }
     }
@@ -23,6 +25,7 @@ impl Language {
             Language::TypeScript => "ts",
             Language::Python => "py",
             Language::Ruby => "rb",
+            Language::Go => "go",
         }
     }
 }

src/extractor/language.rs

@@ -22,6 +22,7 @@ impl Default for ExtractionOptions {
                 "**/*.tsx".to_string(),
                 "**/*.py".to_string(),
                 "**/*.rb".to_string(),
+                "**/*.go".to_string(),
             ],
             exclude_patterns: vec![
                 "**/target/**".to_string(),
@@ -83,6 +84,16 @@ impl CodeExtractor {
                         ))
                     })?;
             }
+            Language::Go => {
+                parser
+                    .set_language(tree_sitter_go::language())
+                    .map_err(|e| {
+                        GitTypeError::ExtractionFailed(format!(
+                            "Failed to set Go language: {}",
+                            e
+                        ))
+                    })?;
+            }
         }
         Ok(parser)
     }
@@ -269,6 +280,12 @@ impl CodeExtractor {
                 (class name: (constant) @name) @class
                 (module name: (constant) @name) @module
             ",
+            Language::Go => "
+                (function_declaration name: (identifier) @name) @function
+                (method_declaration receiver: _ name: (field_identifier) @name) @method
+                (type_spec name: (type_identifier) @name type: (struct_type)) @struct
+                (type_spec name: (type_identifier) @name type: (interface_type)) @interface
+            ",
         };
 
         let query = Query::new(tree.language(), query_str).map_err(|e| {
@@ -351,6 +368,7 @@ impl CodeExtractor {
             "method" => ChunkType::Method,
             "class" | "impl" => ChunkType::Class,
             "struct" => ChunkType::Struct,
+            "interface" => ChunkType::Interface,
             "module" => ChunkType::Module,
             "arrow_function" => ChunkType::Function,
             "function_expression" => ChunkType::Function,
@@ -420,6 +438,7 @@ impl CodeExtractor {
                 if child.kind() == "identifier"
                     || child.kind() == "type_identifier"
                     || child.kind() == "property_identifier"
+                    || child.kind() == "field_identifier"
                     || child.kind() == "constant"
                 {
                     let start = child.start_byte();
@@ -566,6 +585,7 @@ impl CodeExtractor {
             Language::TypeScript => "(comment) @comment",
             Language::Python => "(comment) @comment",
             Language::Ruby => "(comment) @comment",
+            Language::Go => "(comment) @comment",
         };
 
         let query = match Query::new(tree.language(), comment_query) {
@@ -589,6 +609,7 @@ impl CodeExtractor {
                     Language::TypeScript => node_kind == "comment",
                     Language::Python => node_kind == "comment",
                     Language::Ruby => node_kind == "comment",
+                    Language::Go => node_kind == "comment",
                 };
 
                 if !is_valid_comment {

src/extractor/parser.rs

@@ -25,6 +25,7 @@ fn test_language_from_extension() {
     assert_eq!(Language::from_extension("tsx"), Some(Language::TypeScript));
     assert_eq!(Language::from_extension("py"), Some(Language::Python));
     assert_eq!(Language::from_extension("rb"), Some(Language::Ruby));
+    assert_eq!(Language::from_extension("go"), Some(Language::Go));
     assert_eq!(Language::from_extension("unknown"), None);
 }
 
@@ -455,3 +456,156 @@ end
     assert!(method_names.contains(&&"login".to_string()));
     assert!(method_names.contains(&&"logout".to_string()));
 }
+
+#[test]
+fn test_go_function_extraction() {
+    let temp_dir = TempDir::new().unwrap();
+    let file_path = temp_dir.path().join("test.go");
+
+    let go_code = r#"package main
+
+import "fmt"
+
+func main() {
+    fmt.Println("Hello, world!")
+}
+
+func add(a, b int) int {
+    return a + b
+}
+
+func multiply(x int, y int) int {
+    return x * y
+}
+"#;
+    fs::write(&file_path, go_code).unwrap();
+
+    let mut extractor = CodeExtractor::new().unwrap();
+    let chunks = extractor
+        .extract_chunks(temp_dir.path(), ExtractionOptions::default())
+        .unwrap();
+
+    assert_eq!(chunks.len(), 3);
+    
+    let function_names: Vec<&String> = chunks.iter().map(|c| &c.name).collect();
+    assert!(function_names.contains(&&"main".to_string()));
+    assert!(function_names.contains(&&"add".to_string()));
+    assert!(function_names.contains(&&"multiply".to_string()));
+    
+    for chunk in &chunks {
+        assert!(matches!(chunk.chunk_type, ChunkType::Function));
+        assert_eq!(chunk.language, Language::Go);
+    }
+}
+
+#[test]
+fn test_go_struct_extraction() {
+    let temp_dir = TempDir::new().unwrap();
+    let file_path = temp_dir.path().join("test.go");
+
+    let go_code = r#"package main
+
+type Person struct {
+    Name string
+    Age  int
+}
+
+type Address struct {
+    Street string
+    City   string
+    Zip    string
+}
+
+func (p Person) GetName() string {
+    return p.Name
+}
+
+func (a *Address) GetFullAddress() string {
+    return a.Street + ", " + a.City + " " + a.Zip
+}
+"#;
+    fs::write(&file_path, go_code).unwrap();
+
+    let mut extractor = CodeExtractor::new().unwrap();
+    let chunks = extractor
+        .extract_chunks(temp_dir.path(), ExtractionOptions::default())
+        .unwrap();
+
+    assert_eq!(chunks.len(), 4); // 2 structs + 2 methods
+
+    // Find struct chunks
+    let struct_chunks: Vec<_> = chunks
+        .iter()
+        .filter(|c| matches!(c.chunk_type, ChunkType::Struct))
+        .collect();
+    assert_eq!(struct_chunks.len(), 2);
+
+    let struct_names: Vec<&String> = struct_chunks.iter().map(|c| &c.name).collect();
+    assert!(struct_names.contains(&&"Person".to_string()));
+    assert!(struct_names.contains(&&"Address".to_string()));
+
+    // Find method chunks
+    let method_chunks: Vec<_> = chunks
+        .iter()
+        .filter(|c| matches!(c.chunk_type, ChunkType::Method))
+        .collect();
+    assert_eq!(method_chunks.len(), 2);
+
+    let method_names: Vec<&String> = method_chunks.iter().map(|c| &c.name).collect();
+    assert!(method_names.contains(&&"GetName".to_string()));
+    assert!(method_names.contains(&&"GetFullAddress".to_string()));
+}
+
+#[test]
+fn test_go_interface_extraction() {
+    let temp_dir = TempDir::new().unwrap();
+    let file_path = temp_dir.path().join("test.go");
+
+    let go_code = r#"package main
+
+type Writer interface {
+    Write([]byte) (int, error)
+}
+
+type Reader interface {
+    Read([]byte) (int, error)
+}
+
+type ReadWriter interface {
+    Reader
+    Writer
+}
+
+func process(rw ReadWriter) {
+    // Implementation here
+}
+"#;
+    fs::write(&file_path, go_code).unwrap();
+
+    let mut extractor = CodeExtractor::new().unwrap();
+    let chunks = extractor
+        .extract_chunks(temp_dir.path(), ExtractionOptions::default())
+        .unwrap();
+
+    assert_eq!(chunks.len(), 4); // 3 interfaces + 1 function
+
+    // Find interface chunks
+    let interface_chunks: Vec<_> = chunks
+        .iter()
+        .filter(|c| matches!(c.chunk_type, ChunkType::Interface))
+        .collect();
+    assert_eq!(interface_chunks.len(), 3);
+
+    let interface_names: Vec<&String> = interface_chunks.iter().map(|c| &c.name).collect();
+    assert!(interface_names.contains(&&"Writer".to_string()));
+    assert!(interface_names.contains(&&"Reader".to_string()));
+    assert!(interface_names.contains(&&"ReadWriter".to_string()));
+
+    // Find function chunk
+    let function_chunks: Vec<_> = chunks
+        .iter()
+        .filter(|c| matches!(c.chunk_type, ChunkType::Function))
+        .collect();
+    assert_eq!(function_chunks.len(), 1);
+    assert_eq!(function_chunks[0].name, "process");
+}