func main()

in cmd/moduleversion/main.go [37:106]
57 lines of code
14 McCabe index (conditional complexity)

func main() {
	flag.Parse()

	if len(flag.Args()) != 1 {
		flag.Usage()
		log.Fatalf("no module specified")
	}
	moduleToCheck := flag.Args()[0]

	repoRoot, err := repotools.GetRepoRoot()
	if err != nil {
		log.Fatalf("failed to get repository root: %v", err)
	}

	config, err := repotools.LoadConfig(repoRoot)
	if err != nil {
		log.Fatalf("failed to load repotools config: %v", err)
	}

	discoverer := gomod.NewDiscoverer(repoRoot)

	if err := discoverer.Discover(); err != nil {
		log.Fatalf("failed to discover repository modules: %v", err)
	}

	tags, err := git.Tags(repoRoot)
	if err != nil {
		log.Fatalf("failed to get git tags: %v", err)
	}

	taggedModules := git.ParseModuleTags(tags)

	annotations, err := changelog.GetAnnotations(repoRoot)
	if err != nil {
		log.Fatal(err)
	}

	checkedModules, err := release.Calculate(discoverer, taggedModules, config, annotations)
	if err != nil {
		log.Fatalf("failed to check repo modules, %v", err)
	}

	if getUnreleasedVersion {
		id := release.NextReleaseID(tags)
		manifest, err := release.BuildReleaseManifest(discoverer.Modules(), id, checkedModules, false, preview.String())
		if err != nil {
			log.Fatalf("failed to build release manifest, %v", err)
		}

		if m, ok := manifest.Modules[moduleToCheck]; ok {
			moduleTag, err := git.ToModuleTag(moduleToCheck, m.To)
			if err != nil {
				log.Fatalf("failed to get module %v tag, %v", moduleToCheck, err)
			}
			fmt.Println(moduleTag)
			return
		}
	}

	checkedModule, ok := release.FindModuleViaRelativeRepoPath(checkedModules, moduleToCheck)
	if !ok {
		log.Fatalf("failed to find version for module, %v", moduleToCheck)
	}

	moduleVersion := checkedModule.Latest
	if checkedModule.Latest == "" {
		moduleVersion = "v0.0.0-00010101000000-000000000000"
	}
	fmt.Println(moduleVersion)
}