@ctxo/lang-go 0.7.1 → 0.8.0

package/tools/ctxo-go-analyzer/internal/edges/edges_test.go

@@ -0,0 +1,180 @@
+package edges
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/emit"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/load"
+)
+
+func TestExtractCallsAndUses(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"main.go": `package main
+
+type User struct{ Name string }
+
+func (u *User) Greet() string { return "hi " + u.Name }
+
+func greet(u *User) string { return u.Greet() }
+
+func main() {
+	u := &User{Name: "x"}
+	_ = greet(u)
+}
+`,
+	})
+
+	edges := extractAllEdges(t, dir)
+
+	want := map[string]bool{
+		// greet uses *User in its parameter list
+		"main.go::greet::function -> main.go::User::class (uses)": true,
+		// greet calls User.Greet via u.Greet()
+		"main.go::greet::function -> main.go::User.Greet::method (calls)": true,
+		// main calls greet
+		"main.go::main::function -> main.go::greet::function (calls)": true,
+		// main uses User via composite literal &User{}
+		"main.go::main::function -> main.go::User::class (uses)": true,
+	}
+	for key := range want {
+		if !edges[key] {
+			t.Errorf("missing edge: %s\n  got: %v", key, sortedKeys(edges))
+			return
+		}
+	}
+}
+
+func TestCrossPackageCalls(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"pkg/helper/helper.go": `package helper
+
+func Do() int { return 42 }
+`,
+		"main.go": `package main
+
+import "fixture/pkg/helper"
+
+func main() { _ = helper.Do() }
+`,
+	})
+
+	edges := extractAllEdges(t, dir)
+
+	key := "main.go::main::function -> pkg/helper/helper.go::Do::function (calls)"
+	if !edges[key] {
+		t.Errorf("missing cross-package call edge\n  got: %v", sortedKeys(edges))
+	}
+}
+
+func TestGenericCallCarriesTypeArgs(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"main.go": `package main
+
+func ID[T any](v T) T { return v }
+
+func main() { _ = ID[int](1) }
+`,
+	})
+
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
+	}
+	ext := NewExtractor(dir, res.Packages)
+
+	var found bool
+	for _, pkg := range res.Packages {
+		for _, file := range pkg.Syntax {
+			for _, edge := range ext.Extract(pkg, file) {
+				if edge.Kind == "calls" && edge.To == "main.go::ID::function" {
+					if len(edge.TypeArgs) != 1 || edge.TypeArgs[0] != "int" {
+						t.Errorf("typeArgs = %v, want [int]", edge.TypeArgs)
+					}
+					found = true
+				}
+			}
+		}
+	}
+	if !found {
+		t.Error("no calls edge to ID function found")
+	}
+}
+
+func TestNoEdgesToStdlib(t *testing.T) {
+	dir := writeFixture(t, map[string]string{
+		"go.mod": "module fixture\n\ngo 1.22\n",
+		"main.go": `package main
+
+import "strings"
+
+func main() { _ = strings.ToUpper("hi") }
+`,
+	})
+	edges := extractAllEdges(t, dir)
+	for key := range edges {
+		if containsStdlib(key) {
+			t.Errorf("edge leaks stdlib target: %s", key)
+		}
+	}
+}
+
+// ── helpers ──
+
+func extractAllEdges(t *testing.T, dir string) map[string]bool {
+	t.Helper()
+	res := load.Packages(dir)
+	if res.FatalError != nil {
+		t.Fatal(res.FatalError)
+	}
+	ext := NewExtractor(dir, res.Packages)
+	out := map[string]bool{}
+	for _, pkg := range res.Packages {
+		for _, file := range pkg.Syntax {
+			for _, edge := range ext.Extract(pkg, file) {
+				out[formatEdge(edge)] = true
+			}
+		}
+	}
+	return out
+}
+
+func formatEdge(e emit.Edge) string {
+	return e.From + " -> " + e.To + " (" + e.Kind + ")"
+}
+
+func sortedKeys(m map[string]bool) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	return keys
+}
+
+func containsStdlib(key string) bool {
+	for _, prefix := range []string{"strings.", "fmt.", "errors.", "runtime."} {
+		if len(key) >= len(prefix) && key[:len(prefix)] == prefix {
+			return true
+		}
+	}
+	return false
+}
+
+func writeFixture(t *testing.T, files map[string]string) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, body := range files {
+		path := filepath.Join(dir, name)
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}

package/tools/ctxo-go-analyzer/internal/emit/emit.go

@@ -0,0 +1,189 @@
+// Package emit writes JSONL records to an io.Writer. The schema mirrors
+// @ctxo/lang-csharp's RoslynBatchResult shape so the TypeScript composite
+// adapter can consume Go and C# analyzer output through a shared parser.
+package emit
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"sync"
+)
+
+// Symbol is the wire shape for a declared symbol. Matches SymbolNode in
+// @ctxo/plugin-api with optional byte offsets.
+type Symbol struct {
+	SymbolID    string `json:"symbolId"`
+	Name        string `json:"name"`
+	Kind        string `json:"kind"`
+	StartLine   int    `json:"startLine"`
+	EndLine     int    `json:"endLine"`
+	StartOffset *int   `json:"startOffset,omitempty"`
+	EndOffset   *int   `json:"endOffset,omitempty"`
+}
+
+// Edge is the wire shape for a dependency relationship. Kind is one of
+// imports | calls | extends | implements | uses. TypeArgs preserves generic
+// instantiation metadata when Kind == "uses".
+type Edge struct {
+	From     string   `json:"from"`
+	To       string   `json:"to"`
+	Kind     string   `json:"kind"`
+	TypeArgs []string `json:"typeArgs,omitempty"`
+}
+
+// Complexity is the wire shape for per-symbol metrics. Always empty from the
+// Go binary; the tree-sitter layer fills it in.
+type Complexity struct {
+	SymbolID   string `json:"symbolId"`
+	Cyclomatic int    `json:"cyclomatic"`
+}
+
+// FileRecord is emitted once per source file analyzed.
+type FileRecord struct {
+	Type       string       `json:"type"`
+	File       string       `json:"file"`
+	Symbols    []Symbol     `json:"symbols"`
+	Edges      []Edge       `json:"edges"`
+	Complexity []Complexity `json:"complexity"`
+}
+
+// ProjectRecord is emitted once per run to describe module-level edges.
+type ProjectRecord struct {
+	Type     string           `json:"type"`
+	Projects []ProjectEntry   `json:"projects"`
+	Edges    []ProjectEdge    `json:"edges"`
+}
+
+type ProjectEntry struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+}
+
+type ProjectEdge struct {
+	From string `json:"from"`
+	To   string `json:"to"`
+	Kind string `json:"kind"`
+}
+
+// Summary is the final record emitted when analysis completes.
+type Summary struct {
+	Type       string `json:"type"`
+	TotalFiles int    `json:"totalFiles"`
+	Elapsed    string `json:"elapsed"`
+	Hint       string `json:"hint,omitempty"`
+}
+
+// Progress is an optional informational record. Consumed by the TS parser
+// for log-forwarding only; never affects extracted data.
+type Progress struct {
+	Type    string `json:"type"`
+	Message string `json:"message"`
+}
+
+// Dead is emitted once per run, listing function/method symbol ids that are
+// not reachable from the module's entry points. HasMain=false means library
+// mode (reachability approximated via exported API). Timeout=true means the
+// reach analysis exceeded its deadline and dead-code precision is degraded.
+type Dead struct {
+	Type      string   `json:"type"`
+	SymbolIDs []string `json:"symbolIds"`
+	HasMain   bool     `json:"hasMain"`
+	Timeout   bool     `json:"timeout,omitempty"`
+}
+
+// Writer serializes records to JSONL. Writes are serialized internally so a
+// single Writer is safe to share across goroutines.
+type Writer struct {
+	mu  sync.Mutex
+	bw  *bufio.Writer
+	err error
+}
+
+// NewWriter wraps an io.Writer with JSONL framing.
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{bw: bufio.NewWriter(w)}
+}
+
+// File emits a file-scoped record.
+func (w *Writer) File(rec FileRecord) error {
+	rec.Type = "file"
+	if rec.Symbols == nil {
+		rec.Symbols = []Symbol{}
+	}
+	if rec.Edges == nil {
+		rec.Edges = []Edge{}
+	}
+	if rec.Complexity == nil {
+		rec.Complexity = []Complexity{}
+	}
+	return w.writeJSON(rec)
+}
+
+// Project emits the project-graph record.
+func (w *Writer) Project(rec ProjectRecord) error {
+	rec.Type = "projectGraph"
+	if rec.Projects == nil {
+		rec.Projects = []ProjectEntry{}
+	}
+	if rec.Edges == nil {
+		rec.Edges = []ProjectEdge{}
+	}
+	return w.writeJSON(rec)
+}
+
+// Dead emits the unreachable-symbols record.
+func (w *Writer) Dead(rec Dead) error {
+	rec.Type = "dead"
+	if rec.SymbolIDs == nil {
+		rec.SymbolIDs = []string{}
+	}
+	return w.writeJSON(rec)
+}
+
+// Summary emits the terminal summary record and flushes.
+func (w *Writer) Summary(rec Summary) error {
+	rec.Type = "summary"
+	if err := w.writeJSON(rec); err != nil {
+		return err
+	}
+	return w.Flush()
+}
+
+// Progress emits an informational message.
+func (w *Writer) Progress(message string) error {
+	return w.writeJSON(Progress{Type: "progress", Message: message})
+}
+
+// Flush flushes the underlying writer.
+func (w *Writer) Flush() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.err != nil {
+		return w.err
+	}
+	return w.bw.Flush()
+}
+
+func (w *Writer) writeJSON(v any) error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if w.err != nil {
+		return w.err
+	}
+	buf, err := json.Marshal(v)
+	if err != nil {
+		w.err = fmt.Errorf("emit: marshal: %w", err)
+		return w.err
+	}
+	if _, err := w.bw.Write(buf); err != nil {
+		w.err = err
+		return err
+	}
+	if err := w.bw.WriteByte('\n'); err != nil {
+		w.err = err
+		return err
+	}
+	return nil
+}

package/tools/ctxo-go-analyzer/internal/emit/emit_test.go

@@ -0,0 +1,84 @@
+package emit
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestWriterEmitsJSONLWithTypeTag(t *testing.T) {
+	var buf bytes.Buffer
+	w := NewWriter(&buf)
+
+	if err := w.Progress("hello"); err != nil {
+		t.Fatalf("Progress: %v", err)
+	}
+	if err := w.File(FileRecord{File: "pkg/foo.go"}); err != nil {
+		t.Fatalf("File: %v", err)
+	}
+	if err := w.Project(ProjectRecord{}); err != nil {
+		t.Fatalf("Project: %v", err)
+	}
+	if err := w.Summary(Summary{TotalFiles: 1, Elapsed: "1ms"}); err != nil {
+		t.Fatalf("Summary: %v", err)
+	}
+
+	lines := strings.Split(strings.TrimRight(buf.String(), "\n"), "\n")
+	if len(lines) != 4 {
+		t.Fatalf("got %d lines, want 4: %q", len(lines), buf.String())
+	}
+
+	wantTypes := []string{"progress", "file", "projectGraph", "summary"}
+	for i, line := range lines {
+		var parsed map[string]any
+		if err := json.Unmarshal([]byte(line), &parsed); err != nil {
+			t.Fatalf("line %d not JSON: %v (%q)", i, err, line)
+		}
+		if parsed["type"] != wantTypes[i] {
+			t.Errorf("line %d type=%v want %s", i, parsed["type"], wantTypes[i])
+		}
+	}
+}
+
+func TestFileRecordDefaultsEmptySlices(t *testing.T) {
+	var buf bytes.Buffer
+	w := NewWriter(&buf)
+	if err := w.File(FileRecord{File: "x.go"}); err != nil {
+		t.Fatal(err)
+	}
+	_ = w.Flush()
+
+	var parsed map[string]any
+	if err := json.Unmarshal([]byte(strings.TrimRight(buf.String(), "\n")), &parsed); err != nil {
+		t.Fatal(err)
+	}
+	for _, key := range []string{"symbols", "edges", "complexity"} {
+		arr, ok := parsed[key].([]any)
+		if !ok {
+			t.Errorf("%s not a JSON array: %T", key, parsed[key])
+			continue
+		}
+		if len(arr) != 0 {
+			t.Errorf("%s got %d items, want 0", key, len(arr))
+		}
+	}
+}
+
+func TestEdgeTypeArgsOmitEmpty(t *testing.T) {
+	b, err := json.Marshal(Edge{From: "a", To: "b", Kind: "calls"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(b), "typeArgs") {
+		t.Errorf("expected typeArgs omitted, got %s", b)
+	}
+
+	b2, err := json.Marshal(Edge{From: "a", To: "b", Kind: "uses", TypeArgs: []string{"int"}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(b2), `"typeArgs":["int"]`) {
+		t.Errorf("expected typeArgs present, got %s", b2)
+	}
+}

package/tools/ctxo-go-analyzer/internal/extends/extends.go

@@ -0,0 +1,138 @@
+// Package extends derives `extends` edges for struct-field embedding and
+// interface-embedding — Go's closest analog to inheritance. A struct with
+// an anonymous field of type T promotes T's methods; an interface embedding
+// another interface inherits its method set.
+package extends
+
+import (
+	"go/token"
+	"go/types"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/emit"
+	"github.com/alperhankendi/ctxo/tools/ctxo-go-analyzer/internal/symbols"
+)
+
+// Extract returns `extends` edges grouped by the source file of the
+// embedding type (the child). External embeddings (stdlib types promoted
+// into a module-local struct) are skipped — we only care about intra-module
+// inheritance chains for graph traversal.
+func Extract(rootDir string, pkgs []*packages.Package) map[string][]emit.Edge {
+	type entry struct {
+		named *types.Named
+		file  string
+	}
+
+	var named []entry
+	packages.Visit(pkgs, nil, func(p *packages.Package) {
+		if p.Types == nil || p.Fset == nil {
+			return
+		}
+		scope := p.Types.Scope()
+		for _, n := range scope.Names() {
+			if n == "_" {
+				continue
+			}
+			obj := scope.Lookup(n)
+			tn, ok := obj.(*types.TypeName)
+			if !ok {
+				continue
+			}
+			t, ok := tn.Type().(*types.Named)
+			if !ok {
+				continue
+			}
+			if t.TypeParams() != nil && t.TypeParams().Len() > 0 {
+				continue
+			}
+			rel := relFile(p.Fset, obj.Pos(), rootDir)
+			if rel == "" {
+				continue
+			}
+			named = append(named, entry{named: t, file: rel})
+		}
+	})
+
+	// Build a lookup so we can resolve embedded-type references to a file path
+	// and kind without re-traversing packages.
+	typeIndex := make(map[*types.TypeName]entry)
+	for _, e := range named {
+		typeIndex[e.named.Obj()] = e
+	}
+
+	out := map[string][]emit.Edge{}
+	add := func(from entry, target *types.Named, kind string) {
+		tgt, ok := typeIndex[target.Obj()]
+		if !ok {
+			return
+		}
+		fromID := symbols.SymbolID(from.file, from.named.Obj().Name(), kind)
+		toID := symbols.SymbolID(tgt.file, tgt.named.Obj().Name(), kindOf(tgt.named))
+		if fromID == toID {
+			return
+		}
+		out[from.file] = append(out[from.file], emit.Edge{
+			From: fromID,
+			To:   toID,
+			Kind: "extends",
+		})
+	}
+
+	for _, e := range named {
+		switch under := e.named.Underlying().(type) {
+		case *types.Struct:
+			for i := 0; i < under.NumFields(); i++ {
+				f := under.Field(i)
+				if !f.Embedded() {
+					continue
+				}
+				if target := asNamed(f.Type()); target != nil {
+					add(e, target, "class")
+				}
+			}
+		case *types.Interface:
+			for i := 0; i < under.NumEmbeddeds(); i++ {
+				if target := asNamed(under.EmbeddedType(i)); target != nil {
+					add(e, target, "interface")
+				}
+			}
+		}
+	}
+	return out
+}
+
+func asNamed(t types.Type) *types.Named {
+	if p, ok := t.(*types.Pointer); ok {
+		t = p.Elem()
+	}
+	if n, ok := t.(*types.Named); ok {
+		return n
+	}
+	return nil
+}
+
+func kindOf(n *types.Named) string {
+	switch n.Underlying().(type) {
+	case *types.Struct:
+		return "class"
+	case *types.Interface:
+		return "interface"
+	default:
+		return "type"
+	}
+}
+
+func relFile(fset *token.FileSet, pos token.Pos, rootDir string) string {
+	p := fset.Position(pos)
+	if !p.IsValid() {
+		return ""
+	}
+	rel, err := filepath.Rel(rootDir, p.Filename)
+	if err != nil || strings.HasPrefix(rel, "..") {
+		return ""
+	}
+	return filepath.ToSlash(rel)
+}