devlensio 0.6.2 → 1.0.1

package/extractors/go/fingerprint.go

@@ -0,0 +1,167 @@
+// fingerprint.go — go.mod parsing → framework / projectType / databases /
+// rawDependencies. Hand-rolled (bufio.Scanner): the binary must stay stdlib-
+// only, so golang.org/x/mod/modfile is out. Never executes the manifest
+// (same security rule as setup.py / pom.xml).
+
+package main
+
+import (
+	"bufio"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// modFile holds everything the extractor needs from go.mod.
+type modFile struct {
+	ModulePath string
+	GoVersion  string
+	Requires   map[string]string // module path → version
+	Replaces   map[string]string // old module path → new module path (replace directives)
+	HasMod     bool
+}
+
+// parseGoMod reads <repo>/go.mod. Missing file → empty modFile (HasMod=false),
+// which the rest of the extractor treats as "not a Go module" gracefully.
+func parseGoMod(repoPath string) *modFile {
+	mf := &modFile{Requires: map[string]string{}, Replaces: map[string]string{}}
+	f, err := os.Open(filepath.Join(repoPath, "go.mod"))
+	if err != nil {
+		return mf
+	}
+	defer f.Close()
+
+	sc := bufio.NewScanner(f)
+	sc.Buffer(make([]byte, 1024*1024), 1024*1024)
+	inRequire := false
+	for sc.Scan() {
+		line := strings.TrimSpace(stripGoModComment(sc.Text()))
+		if line == "" {
+			continue
+		}
+		if strings.HasPrefix(line, "require (") {
+			inRequire = true
+			continue
+		}
+		if inRequire {
+			if line == ")" {
+				inRequire = false
+				continue
+			}
+			if mod, ver, ok := splitModuleVersion(line); ok {
+				mf.Requires[mod] = ver
+			}
+			continue
+		}
+		switch {
+		case strings.HasPrefix(line, "module "):
+			mf.ModulePath = strings.TrimSpace(strings.TrimPrefix(line, "module "))
+			mf.HasMod = true
+		case strings.HasPrefix(line, "go "):
+			mf.GoVersion = strings.TrimSpace(strings.TrimPrefix(line, "go "))
+		case strings.HasPrefix(line, "require "):
+			if mod, ver, ok := splitModuleVersion(strings.TrimPrefix(line, "require ")); ok {
+				mf.Requires[mod] = ver
+			}
+		case strings.HasPrefix(line, "replace "):
+			// replace old [ver] => new [ver]
+			rest := strings.TrimPrefix(line, "replace ")
+			if i := strings.Index(rest, "=>"); i >= 0 {
+				old := strings.TrimSpace(rest[:i])
+				newp := strings.TrimSpace(rest[i+2:])
+				// strip versions from the old side: "old v1.2.3" → "old"
+				old = strings.Fields(old)[0]
+				// new side may be "mod v1.2.3" or a filesystem path
+				fields := strings.Fields(newp)
+				if len(fields) > 0 {
+					mf.Replaces[old] = fields[0]
+				}
+			}
+		}
+	}
+	return mf
+}
+
+// stripGoModComment removes // comments (not inside strings — go.mod has no
+// string literals in require/module lines, so a plain cut is safe here).
+func stripGoModComment(line string) string {
+	if i := strings.Index(line, "//"); i >= 0 {
+		return line[:i]
+	}
+	return line
+}
+
+// splitModuleVersion splits "mod/path v1.2.3" → (mod/path, v1.2.3).
+func splitModuleVersion(s string) (string, string, bool) {
+	fields := strings.Fields(s)
+	if len(fields) < 2 {
+		return "", "", false
+	}
+	return fields[0], fields[1], true
+}
+
+// ── framework / database detection (documented dep-name conventions) ──
+
+var frameworkDeps = []struct {
+	dep string
+	fw  string
+}{
+	{"github.com/gin-gonic/gin", "gin"},
+	{"github.com/labstack/echo", "echo"},
+	{"github.com/gofiber/fiber", "fiber"},
+}
+
+var databaseDeps = []struct {
+	prefix string
+	db     string
+}{
+	{"gorm.io/gorm", "gorm"},
+	{"github.com/jackc/pgx", "postgresql"},
+	{"github.com/lib/pq", "postgresql"},
+	{"github.com/go-sql-driver/mysql", "mysql"},
+	{"modernc.org/sqlite", "sqlite"},
+	{"github.com/mattn/go-sqlite3", "sqlite"},
+	{"go.mongodb.org/mongo-driver", "mongo"},
+}
+
+// fingerprintFromMod — manifest-only detection. web-framework / database list
+// derived from the require set; net-http and database/sql (both stdlib) are
+// upgraded later by extractor.go once imports are known.
+func fingerprintFromMod(mf *modFile) *Fingerprint {
+	fp := newFingerprint()
+	if !mf.HasMod {
+		return fp
+	}
+	fp.RawDependencies = sortedCopy(mf.Requires)
+	for _, fw := range frameworkDeps {
+		if hasPrefixKey(mf.Requires, fw.dep) {
+			fp.Framework = fw.fw
+			fp.ProjectType = "backend"
+			break
+		}
+	}
+	seen := map[string]bool{}
+	for _, dd := range databaseDeps {
+		if hasPrefixKey(mf.Requires, dd.prefix) && !seen[dd.db] {
+			fp.Databases = append(fp.Databases, dd.db)
+			seen[dd.db] = true
+		}
+	}
+	return fp
+}
+
+// hasPrefixKey — require keys can be "gorm.io/gorm" or "github.com/gofiber/fiber/v2".
+func hasPrefixKey(m map[string]string, prefix string) bool {
+	for k := range m {
+		if k == prefix || strings.HasPrefix(k, prefix+"/") {
+			return true
+		}
+	}
+	return false
+}
+
+func sortedCopy(m map[string]string) map[string]string {
+	// map ordering doesn't matter for JSON (Go marshals maps sorted), but keep
+	// the helper honest.
+	return m
+}

package/extractors/go/go.mod

@@ -0,0 +1,3 @@
+module devlensgoextractor
+
+go 1.26

package/extractors/go/imports.go

@@ -0,0 +1,90 @@
+// imports.go — IMPORTS edges + [mod] third-party nodes + the local-package
+// membership index. No PACKAGE nodes (removed 2026-08-17 — engine-wide
+// connected-only pruning makes package stubs obsolete; import edges now
+// target the imported package's FILES, matching JS/Java/Rust).
+//
+// Resolution (documented Go semantics): an import path is internal when it
+// starts with the module path (honoring `replace` directives, including
+// filesystem replaces) — otherwise external → [mod]/... node (gated). std
+// packages (no dot in first path element) → no node, no edge. Go imports
+// PACKAGES, so the IMPORTS edge fans out from the importing FILE to every
+// non-test FILE of the target package (one edge per file; package identity
+// rides in each file's metadata.package).
+
+package main
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+// detectImports — returns IMPORTS edges + seeds the shared ThirdPartyRegistry
+// (imports/calls/inheritance share one gated registry per extraction) and the
+// PkgNodesByPath membership index (local-vs-external checks in
+// calls/routes/orm/inheritance — key presence only, values unused).
+func detectImports(pr *parsedRepo, l *LookupMaps, opts *Options, fp *Fingerprint) []map[string]any {
+	edges := []map[string]any{}
+
+	l.tp = newThirdPartyRegistry(opts.IncludeThirdPartyLibs, fp, l)
+
+	// Index: import path → non-test files of that package (FILE→FILE targets),
+	// plus import path → dir for filesystem-replace resolution.
+	filesByImportPath := map[string][]string{}
+	dirByImportPath := map[string]string{}
+	for _, pkg := range pr.packages {
+		l.PkgNodesByPath[pkg.ImportPath] = nil // membership marker only
+		relFiles := []string{}
+		for _, pf := range pkg.Files {
+			if pf.IsTest {
+				continue // test files are never import targets (leaf rule)
+			}
+			relFiles = append(relFiles, pf.RelPath)
+		}
+		filesByImportPath[pkg.ImportPath] = relFiles
+		dirByImportPath[pkg.ImportPath] = pkg.Dir
+	}
+	// replace-directive aliases: import path → local dir (filesystem replaces)
+	fsReplaceDir := map[string]string{}
+	for old, newp := range pr.mod.Replaces {
+		if strings.HasPrefix(newp, "./") || strings.HasPrefix(newp, "../") || strings.HasPrefix(newp, "/") {
+			fsReplaceDir[old] = strings.TrimPrefix(filepath.ToSlash(newp), "./")
+		}
+	}
+
+	for _, pf := range pr.files {
+		fileID := "file::" + pf.RelPath
+		for _, imp := range pf.Imports {
+			p := imp.Path
+			if isStdImport(p) {
+				continue // std: no node, no edge
+			}
+			// internal? (a) module-prefixed → package files, (b) replace →
+			// filesystem dir → that package's files
+			targets, ok := filesByImportPath[p]
+			if !ok {
+				if dir, ok := fsReplaceDir[p]; ok {
+					for ip, d := range dirByImportPath {
+						if strings.TrimPrefix(filepath.ToSlash(d), "./") == dir {
+							targets = filesByImportPath[ip]
+							ok = true
+							break
+						}
+					}
+				}
+			}
+			if ok {
+				for _, rel := range targets {
+					edges = append(edges, edgeWithMeta(fileID, "file::"+rel, EdgeImports,
+						map[string]any{"importPath": p}))
+				}
+				continue
+			}
+			// external → [mod]/... (gated)
+			if n := l.tp.packageNode(p); n != nil {
+				edges = append(edges, edgeWithMeta(fileID, n["id"].(string), EdgeImports,
+					map[string]any{"importPath": p, "isThirdParty": true}))
+			}
+		}
+	}
+	return edges
+}

package/extractors/go/inheritance.go

@@ -0,0 +1,138 @@
+// inheritance.go — EXTENDS (struct embedding / interface embedding) +
+// IMPLEMENTS (go/types.Implements — the gold standard: exact method-set
+// satisfaction, pointer receivers included, no guessing).
+
+package main
+
+import (
+	"go/types"
+	"strings"
+)
+
+func detectInheritance(pr *parsedRepo, l *LookupMaps, ti *TypeInfo, opts *Options) []map[string]any {
+	edges := []map[string]any{}
+
+	// ── EXTENDS: embedding ──
+	for _, pf := range pr.files {
+		for _, st := range pf.Structs {
+			from := structNodeID(pf.RelPath, st.Name)
+			for _, emb := range st.Embedded {
+				target := resolveTypeRef(emb, pf, st.PkgPath, l, opts)
+				if target != "" {
+					edges = append(edges, edgeWithMeta(from, target, EdgeExtends, map[string]any{"embedded": emb}))
+				}
+			}
+		}
+		for _, it := range pf.Interfaces {
+			from := interfaceNodeID(pf.RelPath, it.Name)
+			for _, emb := range it.Embedded {
+				target := resolveTypeRef(emb, pf, it.PkgPath, l, opts)
+				if target != "" {
+					edges = append(edges, edgeWithMeta(from, target, EdgeExtends, map[string]any{"embedded": emb}))
+				}
+			}
+		}
+	}
+
+	// ── IMPLEMENTS: exact via go/types ──
+	if ti != nil {
+		for _, pkg := range pr.packages {
+			tp, ok := ti.Pkgs[pkg.ImportPath]
+			if !ok {
+				continue
+			}
+			scope := tp.Scope()
+			// local interfaces of this package
+			type ifaceInfo struct {
+				id  string
+				typ *types.Interface
+			}
+			var ifaces []ifaceInfo
+			for _, pf := range pkg.Files {
+				for _, it := range pf.Interfaces {
+					obj := scope.Lookup(it.Name)
+					if obj == nil {
+						continue
+					}
+					tn, ok := obj.(*types.TypeName)
+					if !ok {
+						continue
+					}
+					if i, ok := tn.Type().Underlying().(*types.Interface); ok {
+						ifaces = append(ifaces, ifaceInfo{id: interfaceNodeID(pf.RelPath, it.Name), typ: i})
+					}
+				}
+			}
+			if len(ifaces) == 0 {
+				continue
+			}
+			// every named type in the package (structs + enums; types without
+			// nodes can't get edges — documented)
+			for _, name := range scope.Names() {
+				obj := scope.Lookup(name)
+				tn, ok := obj.(*types.TypeName)
+				if !ok {
+					continue
+				}
+				if _, isIface := tn.Type().Underlying().(*types.Interface); isIface {
+					continue
+				}
+				id := typeNodeID(l, pkg.ImportPath, name)
+				if id == "" {
+					continue
+				}
+				for _, ifc := range ifaces {
+					if types.Implements(tn.Type(), ifc.typ) || types.Implements(types.NewPointer(tn.Type()), ifc.typ) {
+						edges = append(edges, edgeWithMeta(id, ifc.id, EdgeImplements, map[string]any{}))
+					}
+				}
+			}
+		}
+	}
+	return edges
+}
+
+// resolveTypeRef — embedded type text → node id (local struct/interface node,
+// or gated [mod]/pkg::Member for external embeds like gorm.Model).
+func resolveTypeRef(emb string, pf *ParsedFile, pkgPath string, l *LookupMaps, opts *Options) string {
+	name := strings.TrimPrefix(emb, "*")
+	// qualified: alias.Type
+	if i := strings.Index(name, "."); i >= 0 {
+		alias := name[:i]
+		member := name[i+1:]
+		if impPath, ok := l.SymbolMaps[pf.RelPath][alias]; ok {
+			if _, local := l.PkgNodesByPath[impPath]; local {
+				if id, ok := l.StructNodeByPkgName[impPath+"::"+member]; ok {
+					return id
+				}
+				if id, ok := l.InterfaceNodeByPkgName[impPath+"::"+member]; ok {
+					return id
+				}
+				return ""
+			}
+			// external (e.g. gorm.Model) → gated [mod] member node
+			if n := l.tp.memberNode(impPath, member); n != nil {
+				return n["id"].(string)
+			}
+			return ""
+		}
+		return ""
+	}
+	// unqualified: same package
+	if id, ok := l.StructNodeByPkgName[pkgPath+"::"+name]; ok {
+		return id
+	}
+	if id, ok := l.InterfaceNodeByPkgName[pkgPath+"::"+name]; ok {
+		return id
+	}
+	return ""
+}
+
+// typeNodeID — node id for a named type (struct), or "" if the type has no
+// node (plain aliases, iota enums — documented; enums dropped 2026-08-17).
+func typeNodeID(l *LookupMaps, pkgPath, name string) string {
+	if id, ok := l.StructNodeByPkgName[pkgPath+"::"+name]; ok {
+		return id
+	}
+	return ""
+}

package/extractors/go/lookup.go

@@ -0,0 +1,106 @@
+// lookup.go — LookupMaps: ONE shared index built once from parsed facts,
+// consumed by every edge detector. Edge resolution is dict lookups only —
+// never re-walks ASTs (playbook rule).
+
+package main
+
+import "strings"
+
+type LookupMaps struct {
+	// node id → node map (all emitted nodes register here)
+	NodeByID map[string]map[string]any
+	// file node per rel path
+	FileNodesByPath map[string]map[string]any
+	// PACKAGE node per import path
+	PkgNodesByPath map[string]map[string]any
+	// symbol maps: rel file → import alias → import path (the bridge for
+	// Calls/Routes/Tests — mirrors python's symbol_maps)
+	SymbolMaps map[string]map[string]string
+	// pkgPath::Name → node id (exact per-package resolution; Go type names
+	// are unique per package, so no closest_by_path needed)
+	FuncNodeByPkgName       map[string]string
+	MethodNodeByPkgTypeName map[string]string
+	StructNodeByPkgName     map[string]string
+	InterfaceNodeByPkgName  map[string]string
+	// third-party registry output (gated) — [mod]/... nodes
+	thirdPartyNodes []map[string]any
+	thirdPartyByID  map[string]map[string]any
+	// gated [mod] node factory (imports/calls/inheritance share ONE registry)
+	tp *ThirdPartyRegistry
+}
+
+func buildLookupMaps(pr *parsedRepo, ti *TypeInfo) *LookupMaps {
+	l := &LookupMaps{
+		NodeByID:                map[string]map[string]any{},
+		FileNodesByPath:         map[string]map[string]any{},
+		PkgNodesByPath:          map[string]map[string]any{},
+		SymbolMaps:              map[string]map[string]string{},
+		FuncNodeByPkgName:       map[string]string{},
+		MethodNodeByPkgTypeName: map[string]string{},
+		StructNodeByPkgName:     map[string]string{},
+		InterfaceNodeByPkgName:  map[string]string{},
+		thirdPartyByID:          map[string]map[string]any{},
+	}
+	pkgNameByPath := map[string]string{}
+	for _, pkg := range pr.packages {
+		pkgNameByPath[pkg.ImportPath] = pkg.Name
+	}
+	for _, pkg := range pr.packages {
+		for _, pf := range pkg.Files {
+			// symbol map for this file
+			syms := map[string]string{}
+			for _, imp := range pf.Imports {
+				if imp.Alias == "_" || imp.Alias == "." {
+					continue
+				}
+				alias := imp.Alias
+				if alias == "" {
+					if name, ok := pkgNameByPath[imp.Path]; ok {
+						alias = name
+					} else {
+						alias = lastPathElem(imp.Path)
+					}
+				}
+				syms[alias] = imp.Path
+			}
+			l.SymbolMaps[pf.RelPath] = syms
+
+			// code-node id maps
+			for _, fn := range pf.Funcs {
+				if fn.IsMethod {
+					l.MethodNodeByPkgTypeName[fn.PkgPath+"::"+fn.RecvType+"."+fn.Name] = methodNodeID(pf.RelPath, fn)
+				} else {
+					l.FuncNodeByPkgName[fn.PkgPath+"::"+fn.Name] = funcNodeID(pf.RelPath, fn.Name)
+				}
+			}
+			for _, st := range pf.Structs {
+				if st.IsEnum {
+					continue // iota enums dropped (2026-08-17) — no node, no edge
+				}
+				id := structNodeID(pf.RelPath, st.Name)
+				l.StructNodeByPkgName[st.PkgPath+"::"+st.Name] = id
+			}
+			for _, it := range pf.Interfaces {
+				l.InterfaceNodeByPkgName[it.PkgPath+"::"+it.Name] = interfaceNodeID(pf.RelPath, it.Name)
+			}
+		}
+	}
+	return l
+}
+
+// ── node id schemes (deterministic, file-scoped) ──
+
+func funcNodeID(rel, name string) string        { return rel + "::" + name }
+func methodNodeID(rel string, fn *ParsedFunc) string {
+	return rel + "::" + fn.RecvType + "." + fn.Name
+}
+func structNodeID(rel, name string) string      { return rel + "::" + name }
+func interfaceNodeID(rel, name string) string   { return rel + "::" + name }
+func thirdPartyID(importPath string) string     { return "[mod]/" + importPath }
+
+func lastPathElem(p string) string {
+	if i := strings.LastIndex(p, "/"); i >= 0 {
+		return p[i+1:]
+	}
+	return p
+}

package/extractors/go/main.go

@@ -0,0 +1,57 @@
+// main.go — entry point: stdin JSON {repoPath, options} → stdout JSON
+// ExtractorResult. JSON only on stdout; logs go to stderr.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+)
+
+// Input mirrors ExtractorInput from src/extractors/types.ts.
+type Input struct {
+	RepoPath string          `json:"repoPath"`
+	Options  json.RawMessage `json:"options"`
+}
+
+// Options — the engine forwards includeThirdPartyLibs (both spellings are
+// accepted: engine truth + contract.html docs alias).
+type Options struct {
+	IncludeThirdPartyLibs  []string `json:"includeThirdPartyLibs"`
+	IncludedThirdPartyLibs []string `json:"includedThirdPartyLibs"`
+}
+
+func main() {
+	raw, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error reading stdin:", err)
+		os.Exit(1)
+	}
+	var in Input
+	if err := json.Unmarshal(raw, &in); err != nil {
+		fmt.Fprintln(os.Stderr, "bad input json:", err)
+		os.Exit(1)
+	}
+	if in.RepoPath == "" {
+		fmt.Fprintln(os.Stderr, "repoPath is required")
+		os.Exit(1)
+	}
+	var opts Options
+	if len(in.Options) > 0 {
+		_ = json.Unmarshal(in.Options, &opts) // malformed options → defaults, non-fatal
+	}
+	if len(opts.IncludeThirdPartyLibs) == 0 {
+		opts.IncludeThirdPartyLibs = opts.IncludedThirdPartyLibs
+	}
+
+	result := runExtractor(in.RepoPath, &opts)
+
+	out, err := json.Marshal(result)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error marshaling result:", err)
+		os.Exit(1)
+	}
+	os.Stdout.Write(out)
+}