parser_importpath.go

package repomap

import (
	"os"
	"path/filepath"
	"regexp"
	"strings"
)

var phpNamespaceRe = regexp.MustCompile(`(?i)^namespace\s+([\w\\]+)`)
var javaPackageRe = regexp.MustCompile(`^package\s+([\w.]+)\s*;`)
var cargoNameRe = regexp.MustCompile(`(?m)^name\s*=\s*"([^"]+)"`)
var pkgJSONNameRe = regexp.MustCompile(`"name"\s*:\s*"([^"]+)"`)

// deriveImportPath returns the best-available parser identity for a non-Go
// file. It is intentionally coarse: ranking and dependency analysis need a
// stable logical package/module/namespace within the repository, not a global
// import path.
func deriveImportPath(absPath, root, lang string, lines []string) string {
	switch lang {
	case "php":
		return derivePHPNamespace(lines)
	case "python":
		return derivePythonPackage(absPath, root)
	case "java":
		return deriveJavaPackage(lines)
	case "rust":
		return deriveRustCratePath(absPath, root)
	case "typescript", "tsx", "javascript", "jsx":
		return deriveTSPackagePath(absPath, root)
	}
	return ""
}

func derivePHPNamespace(lines []string) string {
	for _, line := range lines {
		if m := phpNamespaceRe.FindStringSubmatch(strings.TrimSpace(line)); m != nil {
			return m[1]
		}
	}
	return ""
}

func derivePythonPackage(absPath, root string) string {
	dir := filepath.Dir(absPath)
	if !strings.HasPrefix(dir, root) {
		return ""
	}
	var parts []string
	for {
		if _, err := os.Stat(filepath.Join(dir, "__init__.py")); err != nil {
			break
		}
		parts = append([]string{filepath.Base(dir)}, parts...)
		parent := filepath.Dir(dir)
		if parent == dir || !strings.HasPrefix(parent, root) {
			break
		}
		dir = parent
	}
	return strings.Join(parts, ".")
}

func deriveJavaPackage(lines []string) string {
	for _, line := range lines {
		if m := javaPackageRe.FindStringSubmatch(strings.TrimSpace(line)); m != nil {
			return m[1]
		}
	}
	return ""
}

func deriveRustCratePath(absPath, root string) string {
	crateName, crateRoot := findCargoToml(absPath, root)
	if crateName == "" {
		return ""
	}
	rel, err := filepath.Rel(crateRoot, absPath)
	if err != nil {
		return ""
	}
	rel = strings.TrimPrefix(rel, "src"+string(filepath.Separator))
	rel = strings.TrimSuffix(rel, ".rs")
	rel = strings.ReplaceAll(rel, string(filepath.Separator), "::")
	rel = strings.TrimSuffix(rel, "::mod")
	if rel == "mod" || rel == "" {
		rel = "lib"
	}
	return crateName + "::" + rel
}

func findCargoToml(absPath, root string) (string, string) {
	for dir := filepath.Dir(absPath); ; dir = filepath.Dir(dir) {
		if !strings.HasPrefix(dir, root) {
			return "", ""
		}
		if data, err := os.ReadFile(filepath.Join(dir, "Cargo.toml")); err == nil {
			if name := parseCargoName(string(data)); name != "" {
				return name, dir
			}
		}
		if parent := filepath.Dir(dir); parent == dir {
			return "", ""
		}
	}
}

func parseCargoName(content string) string {
	if m := cargoNameRe.FindStringSubmatch(content); m != nil {
		return m[1]
	}
	return ""
}

func deriveTSPackagePath(absPath, root string) string {
	pkgName, pkgRoot := findPackageJSON(absPath, root)
	if pkgName == "" {
		return ""
	}
	rel, err := filepath.Rel(pkgRoot, absPath)
	if err != nil {
		return ""
	}
	rel = strings.TrimSuffix(rel, filepath.Ext(rel))
	rel = strings.TrimSuffix(filepath.ToSlash(rel), "/index")
	if rel == "" || rel == "index" {
		return pkgName
	}
	return pkgName + "/" + rel
}

func findPackageJSON(absPath, root string) (string, string) {
	for dir := filepath.Dir(absPath); ; dir = filepath.Dir(dir) {
		if !strings.HasPrefix(dir, root) {
			return "", ""
		}
		if data, err := os.ReadFile(filepath.Join(dir, "package.json")); err == nil {
			if name := parsePackageJSONName(string(data)); name != "" {
				return name, dir
			}
		}
		if parent := filepath.Dir(dir); parent == dir {
			return "", ""
		}
	}
}

func parsePackageJSONName(content string) string {
	if m := pkgJSONNameRe.FindStringSubmatch(content); m != nil {
		return m[1]
	}
	return ""
}