golang

Go Code Analyzer

Analizor de cod Go pentru extragerea simbolurilor, structurii și documentației din fișiere Go. Folosește AST-ul nativ Go pentru parsare precisă. Indexează codul pentru căutare semantică în Qdrant.

Status: ✅ PRODUCTION READY

🎯 Ce Face Acest Analizor?

Analizorul Go parsează fișierele .go și extrage:

1. Simboluri - funcții, metode, tipuri (struct/interface), constante, variabile
2. Documentație - comentarii GoDoc pentru toate simbolurile
3. Metadate - semnături, parametri, return types, receivers
4. Exemple - funcții Example* pentru documentație

📊 Fluxul de Date

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│  Fișiere .go    │────▶│   Go Analyzer    │────▶│   CodeChunks    │
│  (cod sursă)    │     │  (go/ast parser) │     │   (structurat)  │
└─────────────────┘     └──────────────────┘     └────────┬────────┘
                                                          │
                                                          ▼
                                                 ┌─────────────────┐
                                                 │     Qdrant      │
                                                 │  (vector store) │
                                                 └─────────────────┘

🔍 Ce Indexăm

1. Funcții (type: "function")

// ProcessData transformă datele de intrare în formatul dorit.
// Returnează eroare dacă datele sunt invalide.
func ProcessData(input []byte, options ...Option) (Result, error) {
    // implementare
}

Informații extrase:

2. Metode (type: "method")

// Save persistă utilizatorul în baza de date.
func (u *User) Save(ctx context.Context) error {
    return u.db.Save(ctx, u)
}

Informații extrase:

3. Structuri (type: "struct")

// User reprezintă un utilizator în sistem.
type User struct {
    ID        int64     `json:"id" db:"id"`
    Name      string    `json:"name" db:"name"`
    Email     string    `json:"email" db:"email"`
    CreatedAt time.Time `json:"created_at" db:"created_at"`
}

Informații extrase:

4. Interfețe (type: "interface")

// Repository definește operațiile de persistență.
type Repository interface {
    // Find caută o entitate după ID.
    Find(ctx context.Context, id int64) (*Entity, error)
    // Save persistă o entitate.
    Save(ctx context.Context, entity *Entity) error
    // Delete șterge o entitate.
    Delete(ctx context.Context, id int64) error
}

Informații extrase:

5. Constante (type: "const")

// StatusActive reprezintă un utilizator activ.
const StatusActive = "active"

const (
    // MaxRetries este numărul maxim de reîncercări.
    MaxRetries = 3
    // DefaultTimeout este timeout-ul implicit.
    DefaultTimeout = 30 * time.Second
)

Informații extrase:

6. Variabile (type: "var")

// DefaultConfig conține configurația implicită.
var DefaultConfig = Config{
    Timeout: 30 * time.Second,
    Retries: 3,
}

🏗️ Structura Fișierelor

golang/
├── types.go           # Tipuri: PackageInfo, FunctionInfo, TypeInfo, etc.
├── analyzer.go        # PathAnalyzer implementation (800+ linii)
├── api_analyzer.go    # APIAnalyzer pentru documentație API
├── analyzer_test.go   # Teste CodeAnalyzer
├── api_analyzer_test.go # Teste APIAnalyzer
└── README.md          # Această documentație

💻 Utilizare

Analiză Package

import "github.com/doITmagic/rag-code-mcp/internal/ragcode/analyzers/golang"

// Creare analizor
analyzer := golang.NewCodeAnalyzer()

// Analiză un package
pkgInfo, err := analyzer.AnalyzePackage("./internal/mypackage")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Package: %s\n", pkgInfo.Name)
fmt.Printf("Functions: %d\n", len(pkgInfo.Functions))
fmt.Printf("Types: %d\n", len(pkgInfo.Types))

Analiză Multiple Paths (PathAnalyzer interface)

// Analiză directoare/fișiere
chunks, err := analyzer.AnalyzePaths([]string{"./internal/..."})

for _, chunk := range chunks {
    fmt.Printf("[%s] %s.%s\n", chunk.Type, chunk.Package, chunk.Name)
}

🔌 Integrare

Language Manager

Analizorul Go este selectat automat pentru:

• go - proiecte Go
• golang - alternativă

Detectare Workspace

📋 Tipuri de CodeChunk

🏷️ Metadate Complete

Function/Method Metadata

{
  "is_exported": true,
  "is_method": true,
  "receiver": "*User",
  "parameters": [
    {"name": "ctx", "type": "context.Context"},
    {"name": "id", "type": "int64"}
  ],
  "returns": [
    {"type": "*Entity"},
    {"type": "error"}
  ]
}

Type Metadata

{
  "kind": "struct",
  "is_exported": true,
  "fields": [
    {"name": "ID", "type": "int64", "tag": "json:\"id\""},
    {"name": "Name", "type": "string", "tag": "json:\"name\""}
  ],
  "methods": [
    {"name": "Save", "signature": "func (u *User) Save() error"}
  ]
}

🧪 Testare

# Rulează toate testele Go analyzer
go test ./internal/ragcode/analyzers/golang/...

# Cu output verbose
go test -v ./internal/ragcode/analyzers/golang/...

# Cu coverage
go test -cover ./internal/ragcode/analyzers/golang/...

📦 Dependențe

Folosește doar biblioteca standard Go:

• go/ast - Abstract Syntax Tree
• go/parser - Parser Go
• go/doc - Extragere documentație
• go/token - Tokenizare
• go/types - Informații despre tipuri

🚫 Căi Excluse

Analizorul sare automat:

• *_test.go - fișiere de test
• vendor/ - dependențe vendored
• testdata/ - date de test
• .git/ - Git

⚠️ Limitări

🔮 Îmbunătățiri Viitoare

• Suport complet generics (Go 1.18+)
• Cross-package type resolution
• Dependency graph între packages
• Test coverage analysis
• Benchmark detection