[chore] Add context to debug output

Each debug statement is prefixed with "[X] func" where X is either ENV
for debug in environment's methods or PKG for debug in package's
methods.

6 files changed, 94 insertions, 79 deletions

diff --git a/beku.go b/beku.go
index 2330c22..d169318 100644
--- a/beku.go
+++ b/beku.go
@@ -12,11 +12,6 @@ const (
 )
 
 const (
-	dbgLinkDep  = "linking dep"
-	dbgMissDep  = "missing dep"
-	dbgSkipSelf = "skip self dep"
-	dbgSkipStd  = "skip std dep"
-
 	defPATH = "/bin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin"
 
 	dirDB       = "var/beku"
diff --git a/common.go b/common.go
index 1d5ee17..6ec2023 100644
--- a/common.go
+++ b/common.go
@@ -174,7 +174,7 @@ func confirm(in io.Reader, msg string, defIsYes bool) bool {
 		yon = "[Y/n]"
 	}
 
-	fmt.Printf("%s %s: ", msg, yon)
+	fmt.Printf("%s %s ", msg, yon)
 
 	for {
 		b, err = r.ReadByte()
diff --git a/env.go b/env.go
index 71b46c1..e438c67 100644
--- a/env.go
+++ b/env.go
@@ -98,12 +98,12 @@ func (env *Env) addExclude(importPath string) bool {
 
 func (env *Env) cleanUnused() {
 	for _, pkg := range env.pkgsUnused {
-		fmt.Println(">>> Removing source at", pkg.FullPath)
+		fmt.Println("[ENV] cleanUnused >>>", pkg.FullPath)
 		_ = pkg.Remove()
 
 		pkgPath := filepath.Join(env.dirPkg, pkg.ImportPath)
 
-		fmt.Println(">>> Removing installed binaries at", pkgPath)
+		fmt.Println("[ENV] cleanUnused >>>", pkgPath)
 		_ = os.RemoveAll(pkgPath)
 		_ = RmdirEmptyAll(pkgPath)
 	}
@@ -144,7 +144,7 @@ func (env *Env) Freeze() (err error) {
 	)
 
 	for _, pkg := range env.pkgs {
-		fmt.Printf(">>> Freezing %s@%s\n", pkg.ImportPath, pkg.Version)
+		fmt.Printf("[ENV] Freeze >>> %s@%s\n", pkg.ImportPath, pkg.Version)
 
 		localPkg, err = env.GetPackage(pkg.ImportPath)
 		if err != nil {
@@ -173,11 +173,11 @@ func (env *Env) Freeze() (err error) {
 	}
 
 	if len(env.pkgsUnused) == 0 {
-		fmt.Println(">>> No unused packages found.")
+		fmt.Println("[ENV] Freeze >>> No unused packages found.")
 		goto out
 	}
 
-	fmt.Printf("\n>>> The following packages will be cleaned,\n\n")
+	fmt.Println("[ENV] Freeze >>> The following packages will be cleaned,")
 	for _, pkg := range env.pkgsUnused {
 		fmt.Printf("  * %s\n", pkg.ImportPath)
 	}
@@ -195,7 +195,7 @@ func (env *Env) Freeze() (err error) {
 
 out:
 	env.reinstallAll()
-	fmt.Println(">>> Freeze completed.")
+	fmt.Println("[ENV] Freeze >>> finished")
 
 	return
 }
@@ -396,7 +396,7 @@ func (env *Env) scanStdPackages(srcPath string) error {
 //
 func (env *Env) scanPackages(srcPath string) (err error) {
 	if Debug >= DebugL2 {
-		fmt.Println(">>> Scanning", srcPath)
+		fmt.Println("[ENV] scanPackages >>>", srcPath)
 	}
 
 	fis, err := ioutil.ReadDir(srcPath)
@@ -467,7 +467,7 @@ func (env *Env) newPackage(fullPath string) (err error) {
 	}
 
 	if Debug >= DebugL2 {
-		fmt.Println(">>> Scanning package:", pkg.ImportPath)
+		fmt.Println("[ENV] newPackage >>>", pkg.ImportPath)
 	}
 
 	err = pkg.Scan()
@@ -535,7 +535,7 @@ func (env *Env) Load(file string) (err error) {
 	}
 
 	if Debug >= DebugL1 {
-		fmt.Println(">>> Env.Load:", env.dbFile)
+		fmt.Println("[ENV] Load >>>", env.dbFile)
 	}
 
 	env.db, err = ini.Open(env.dbFile)
@@ -624,7 +624,7 @@ func (env *Env) Rescan(firstTime bool) (ok bool, err error) {
 	format := fmt.Sprintf("%%-%ds  %%-12s  %%-12s\n", env.fmtMaxPath)
 
 	if env.countUpdate > 0 {
-		fmt.Printf(">>> The following packages will be updated,\n\n")
+		fmt.Println("[ENV] Rescan >>> New updates,")
 		fmt.Printf(format+"\n", "ImportPath", "Old Version", "New Version")
 
 		for _, pkg := range env.pkgs {
@@ -636,7 +636,7 @@ func (env *Env) Rescan(firstTime bool) (ok bool, err error) {
 		}
 	}
 	if env.countNew > 0 {
-		fmt.Printf("\n>>> New packages,\n\n")
+		fmt.Println("[ENV] Rescan >>> New packages,")
 		fmt.Printf(format+"\n", "ImportPath", "Old Version", "New Version")
 
 		for _, pkg := range env.pkgs {
@@ -652,7 +652,7 @@ func (env *Env) Rescan(firstTime bool) (ok bool, err error) {
 		if firstTime {
 			env.dirty = true
 		} else {
-			fmt.Println(">>> Database and GOPATH is in sync.")
+			fmt.Println("[ENV] Rescan >>> Database is in sync.")
 		}
 		return true, nil
 	}
@@ -734,7 +734,7 @@ This package is required by,
 	}
 	listRemoved = append(listRemoved, pkg.ImportPath)
 
-	fmt.Println("The following package will be removed,")
+	fmt.Println("[ENV] Remove >>> The following package will be removed,")
 	for _, importPath := range listRemoved {
 		fmt.Println(" *", importPath)
 	}
@@ -756,7 +756,7 @@ This package is required by,
 		pkgImportPath := filepath.Join(env.dirPkg, importPath)
 
 		if Debug >= DebugL1 {
-			fmt.Println(">>> Removing", pkgImportPath)
+			fmt.Println("[ENV] Remove >>> Removing", pkgImportPath)
 		}
 
 		err = os.RemoveAll(pkgImportPath)
@@ -879,7 +879,7 @@ func (env *Env) Save(file string) (err error) {
 	}
 
 	if Debug >= DebugL1 {
-		fmt.Println(">>> Saving database:", file)
+		fmt.Println("[ENV] Save >>>", file)
 	}
 
 	dir := filepath.Dir(file)
@@ -942,6 +942,7 @@ func (env *Env) String() string {
 	var buf bytes.Buffer
 
 	fmt.Fprintf(&buf, `
+[ENV]
             Dir bin: %s
             Dir pkg: %s
             Dir src: %s
@@ -953,10 +954,8 @@ func (env *Env) String() string {
 		fmt.Fprintf(&buf, "%s", env.pkgs[x].String())
 	}
 
-	fmt.Fprintf(&buf, "\n[package \"_missing_\"]\n")
-
 	for x := range env.pkgsMissing {
-		fmt.Fprintln(&buf, "ImportPath =", env.pkgsMissing[x])
+		fmt.Fprintln(&buf, "missing =", env.pkgsMissing[x])
 	}
 
 	return buf.String()
@@ -967,7 +966,7 @@ func (env *Env) String() string {
 //
 func (env *Env) install(pkg *Package) (ok bool, err error) {
 	if !IsDirEmpty(pkg.FullPath) {
-		fmt.Printf(">>> Directory %s is not empty.\n", pkg.FullPath)
+		fmt.Printf("[ENV] install >>> Directory %s is not empty.\n", pkg.FullPath)
 		if !env.NoConfirm {
 			ok = confirm(os.Stdin, msgCleanDir, false)
 			if !ok {
@@ -1000,17 +999,17 @@ func (env *Env) update(curPkg, newPkg *Package) (ok bool, err error) {
 	}
 
 	if Debug >= DebugL1 {
-		fmt.Println(">>> Sync:\n", newPkg)
+		fmt.Println("[ENV] update >>>", newPkg)
 	}
 
 	if curPkg.IsEqual(newPkg) {
-		fmt.Printf("Nothing to update.\n")
+		fmt.Println("[ENV] update >>> All package is up todate.")
 		ok = true
 		return
 	}
 
-	fmt.Printf("Updating package from,\n%s\nto,\n%s\n", curPkg.String(),
-		newPkg.String())
+	fmt.Printf("[ENV] update >>> Updating package from,\n%s\nto,\n%s\n",
+		curPkg.String(), newPkg.String())
 
 	if env.NoConfirm {
 		ok = true
@@ -1047,7 +1046,7 @@ func (env *Env) update(curPkg, newPkg *Package) (ok bool, err error) {
 // installMissing will install all missing packages.
 //
 func (env *Env) installMissing(pkg *Package) (err error) {
-	fmt.Printf("[ENV] installMissing: %s\n", pkg.ImportPath)
+	fmt.Printf("[ENV] installMissing %s\n", pkg.ImportPath)
 
 	for _, misImportPath := range pkg.DepsMissing {
 		_, misPkg := env.GetPackageFromDB(misImportPath, "")
@@ -1055,9 +1054,12 @@ func (env *Env) installMissing(pkg *Package) (err error) {
 			continue
 		}
 
+		fmt.Printf("[ENV] installMissing %s >>> %s\n", pkg.ImportPath,
+			misImportPath)
+
 		err = env.Sync(misImportPath, misImportPath)
 		if err != nil {
-			fmt.Fprintf(defStderr, "[ENV] installMissing: %s\n", err)
+			fmt.Fprintf(defStderr, "[ENV] installMissing >>> %s\n", err)
 			continue
 		}
 	}
@@ -1074,7 +1076,7 @@ func (env *Env) updateMissing(newPkg *Package, addAsDep bool) {
 	var updated bool
 
 	if Debug >= DebugL1 {
-		fmt.Println(">>> Update missing:", newPkg.ImportPath)
+		fmt.Println("[ENV] updateMissing >>>", newPkg.ImportPath)
 	}
 
 	for x := 0; x < len(env.pkgs); x++ {
@@ -1193,24 +1195,24 @@ func (env *Env) SyncAll() (err error) {
 	)
 
 	format := fmt.Sprintf("%%-%ds  %%-12s  %%-12s %%s\n", env.fmtMaxPath)
-	fmt.Fprintf(&buf, ">>> The following packages will be updated,\n\n")
+	fmt.Fprintf(&buf, "[ENV] SyncAll >>> The following packages will be updated,\n\n")
 	fmt.Fprintf(&buf, format+"\n", "ImportPath", "Old Version",
 		"New Version", "Compare URL")
 
-	fmt.Println(">>> Updating all packages ...")
+	fmt.Println("[ENV] SyncAll >>> Updating all packages ...")
 
 	for _, pkg := range env.pkgs {
-		fmt.Printf("\n>>> Updating %s %s\n", pkg.ImportPath, pkg.Version)
+		fmt.Printf("[ENV] SyncAll >>> %s %s\n", pkg.ImportPath, pkg.Version)
 		err = pkg.Fetch()
 		if err != nil {
 			return
 		}
 		if pkg.Version == pkg.VersionNext {
-			fmt.Println(">>> No update.")
+			fmt.Println("[ENV] SyncAll >>> No update.")
 			continue
 		}
 
-		fmt.Printf(">>> Latest version is %s\n", pkg.VersionNext)
+		fmt.Printf("[ENV] SyncAll >>> Latest version is %s\n", pkg.VersionNext)
 
 		compareURL := GetCompareURL(pkg.RemoteURL, pkg.Version,
 			pkg.VersionNext)
@@ -1222,7 +1224,7 @@ func (env *Env) SyncAll() (err error) {
 	}
 
 	if countUpdate == 0 {
-		fmt.Println(">>> All packages are up to date.")
+		fmt.Println("[ENV] SyncAll >>> All packages are up to date.")
 		return
 	}
 
@@ -1275,7 +1277,7 @@ func (env *Env) postSync(curPkg, newPkg *Package) (err error) {
 		_ = curPkg.GoInstall()
 	}
 
-	fmt.Println(">>> Package installed:\n", curPkg)
+	fmt.Println("[ENV] postSync >>> Package installed:\n", curPkg)
 
 	return
 }
diff --git a/package.go b/package.go
index 2aff41d..23f0b4b 100644
--- a/package.go
+++ b/package.go
@@ -51,13 +51,13 @@ func NewPackage(pkgName, importPath string) (
 ) {
 	repoRoot, err := vcs.RepoRootForImportPath(pkgName, Debug >= DebugL2)
 	if err != nil {
-		fmt.Fprintf(defStderr, "NewPackage: error: %s\n", err.Error())
-		fmt.Fprintf(defStderr, "NewPackage: skip %s\n", pkgName)
+		fmt.Fprintf(defStderr, "[PKG] NewPackage >>> error: %s\n", err.Error())
+		fmt.Fprintf(defStderr, "[PKG] NewPackage >>> skip %s\n", pkgName)
 		return
 	}
 
 	if Debug >= DebugL2 {
-		fmt.Printf("NewPackage: %+v\n", *repoRoot)
+		fmt.Printf("[PKG] NewPackage >>> %+v\n", *repoRoot)
 	}
 
 	if repoRoot.VCS.Cmd != VCSModeGit {
@@ -134,7 +134,7 @@ func (pkg *Package) GoClean() (err error) {
 	cmd.Stderr = defStderr
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] GoClean %s >>> %s %s\n", pkg.ImportPath, cmd.Dir, cmd.Args)
 	}
 
 	err = cmd.Run()
@@ -199,7 +199,8 @@ func (pkg *Package) Remove() (err error) {
 	}
 
 	if Debug >= DebugL1 {
-		fmt.Println(">>> Remove source:", pkg.FullPath)
+		fmt.Printf("[PKG] Remove %s >>> %s\n", pkg.ImportPath,
+			pkg.FullPath)
 	}
 
 	err = os.RemoveAll(pkg.FullPath)
@@ -259,7 +260,7 @@ func (pkg *Package) Scan() (err error) {
 //
 func (pkg *Package) ScanDeps(env *Env) (err error) {
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> Scanning dependencies for %s ...\n", pkg.ImportPath)
+		fmt.Println("[PKG] ScanDeps", pkg.ImportPath)
 	}
 
 	imports, err := pkg.GetRecursiveImports()
@@ -267,10 +268,6 @@ func (pkg *Package) ScanDeps(env *Env) (err error) {
 		return
 	}
 
-	if Debug >= DebugL2 && len(imports) > 0 {
-		fmt.Println("   imports recursive:", imports)
-	}
-
 	for x := 0; x < len(imports); x++ {
 		pkg.addDep(env, imports[x])
 	}
@@ -295,7 +292,8 @@ func (pkg *Package) GetRecursiveImports() (
 	}
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] GetRecursiveImports %s >>> %s %s\n",
+			pkg.ImportPath, cmd.Dir, cmd.Args)
 	}
 
 	out, err := cmd.Output()
@@ -323,10 +321,6 @@ func (pkg *Package) GetRecursiveImports() (
 
 	sort.Strings(imports)
 
-	if Debug >= DebugL2 {
-		fmt.Println(">>> GetRecursiveImports: imports", imports)
-	}
-
 	return
 }
 
@@ -357,7 +351,8 @@ func (pkg *Package) addDep(env *Env, importPath string) bool {
 	// (1)
 	if strings.HasPrefix(importPath, pkg.ImportPath) {
 		if Debug >= DebugL2 {
-			fmt.Printf("%15s >>> %s\n", dbgSkipSelf, importPath)
+			fmt.Printf("[PKG] addDep %s >>> skip self import: %s\n",
+				pkg.ImportPath, importPath)
 		}
 		return false
 	}
@@ -379,7 +374,8 @@ func (pkg *Package) addDep(env *Env, importPath string) bool {
 			continue
 		}
 		if Debug >= DebugL2 {
-			fmt.Printf("%15s >>> %s\n", dbgSkipStd, importPath)
+			fmt.Printf("[PKG] addDep %s >>> skip std: %s\n",
+				pkg.ImportPath, importPath)
 		}
 		return false
 	}
@@ -397,7 +393,8 @@ func (pkg *Package) addDep(env *Env, importPath string) bool {
 	}
 
 	if Debug >= DebugL2 {
-		fmt.Printf("%15s >>> %s\n", dbgMissDep, importPath)
+		fmt.Printf("[PKG] addDep %s >>> missing: %s\n",
+			pkg.ImportPath, importPath)
 	}
 
 	// (5.2)
@@ -459,7 +456,8 @@ func (pkg *Package) GoInstall() (err error) {
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
 
-	fmt.Printf(">>> %s %s %s\n", cmd.Dir, cmd.Env, cmd.Args)
+	fmt.Printf("[PKG] GoInstall %s >>> %s %s %s\n", pkg.ImportPath,
+		cmd.Dir, cmd.Env, cmd.Args)
 
 	err = cmd.Run()
 
@@ -474,17 +472,20 @@ func (pkg *Package) String() string {
 
 	fmt.Fprintf(&buf, `
 [package "%s"]
+     FullPath = %s
+     ScanPath = %s
           VCS = %s
    RemoteName = %s
     RemoteURL = %s
-     ScanPath = %s
       Version = %s
+  VersionNext = %s
         IsTag = %v
          Deps = %v
    RequiredBy = %v
   DepsMissing = %v
-`, pkg.ImportPath, pkg.vcsMode, pkg.RemoteName, pkg.RemoteURL, pkg.ScanPath,
-		pkg.Version, pkg.isTag, pkg.Deps, pkg.RequiredBy, pkg.DepsMissing)
+`, pkg.ImportPath, pkg.FullPath, pkg.ScanPath, pkg.vcsMode, pkg.RemoteName,
+		pkg.RemoteURL, pkg.Version, pkg.VersionNext, pkg.isTag,
+		pkg.Deps, pkg.RequiredBy, pkg.DepsMissing)
 
 	return buf.String()
 }
@@ -569,7 +570,8 @@ func (pkg *Package) pushDep(importPath string) bool {
 	pkg.Deps = append(pkg.Deps, importPath)
 
 	if Debug >= DebugL2 {
-		fmt.Printf("%15s >>> %s\n", dbgLinkDep, importPath)
+		fmt.Printf("[PKG] pushDep %s >>> %s\n", pkg.ImportPath,
+			importPath)
 	}
 
 	return true
diff --git a/package_git.go b/package_git.go
index 0f41551..1f6d52d 100644
--- a/package_git.go
+++ b/package_git.go
@@ -19,7 +19,8 @@ func (pkg *Package) gitCheckoutVersion(version string) (err error) {
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
 
-	fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+	fmt.Printf("[PKG] gitCheckoutVersion %s >>> %s %s\n", pkg.ImportPath,
+		cmd.Dir, cmd.Args)
 
 	err = cmd.Run()
 	if err != nil {
@@ -33,7 +34,8 @@ func (pkg *Package) gitCheckoutVersion(version string) (err error) {
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
 
-	fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+	fmt.Printf("[PKG] gitCheckoutVersion %s >>> %s %s\n", pkg.ImportPath,
+		cmd.Dir, cmd.Args)
 
 	err = cmd.Run()
 	if err != nil {
@@ -46,7 +48,8 @@ func (pkg *Package) gitCheckoutVersion(version string) (err error) {
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
 
-	fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+	fmt.Printf("[PKG] gitCheckoutVersion %s >>> %s %s\n", pkg.ImportPath,
+		cmd.Dir, cmd.Args)
 
 	_ = cmd.Run()
 
@@ -77,7 +80,8 @@ func (pkg *Package) gitClone() (err error) {
 	cmd.Stderr = defStderr
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] gitClone %s >>> %s %s\n", pkg.ImportPath,
+			cmd.Dir, cmd.Args)
 	}
 
 	err = cmd.Run()
@@ -95,13 +99,15 @@ func (pkg *Package) gitClone() (err error) {
 func (pkg *Package) gitCompareVersion(newPkg *Package) (err error) {
 	//nolint:gas
 	cmd := exec.Command("git", "log", "--oneline", pkg.Version+"..."+newPkg.Version)
-	if Debug >= DebugL1 {
-		fmt.Println(">>>", cmd.Args)
-	}
 	cmd.Dir = pkg.FullPath
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
 
+	if Debug >= DebugL1 {
+		fmt.Printf("[PKG] gitCompareVersion %s >>> %s %s\n",
+			pkg.ImportPath, cmd.Dir, cmd.Args)
+	}
+
 	err = cmd.Run()
 	if err != nil {
 		err = fmt.Errorf("gitCompareVersion: %s", err)
@@ -124,7 +130,8 @@ func (pkg *Package) gitFetch() (err error) {
 	cmd.Stderr = defStderr
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] gitFetch %s >>> %s %s\n", pkg.ImportPath,
+			cmd.Dir, cmd.Args)
 	}
 
 	err = cmd.Run()
@@ -153,7 +160,8 @@ func (pkg *Package) gitGetCommit(ref string) (commit string, err error) {
 	cmd.Dir = pkg.FullPath
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] gitGetCommit %s >>> %s %s\n",
+			pkg.ImportPath, cmd.Dir, cmd.Args)
 	}
 
 	bcommit, err := cmd.Output()
@@ -176,7 +184,8 @@ func (pkg *Package) gitGetTag() (tag string, err error) {
 	cmd.Dir = pkg.FullPath
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] gitGetTag %s >>> %s %s\n", pkg.ImportPath,
+			cmd.Dir, cmd.Args)
 	}
 
 	btag, err := cmd.Output()
@@ -196,7 +205,8 @@ func (pkg *Package) gitGetTagLatest() (tag string, err error) {
 	cmd.Dir = pkg.FullPath
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] gitGetTagLatest %s >>> %s %s\n",
+			pkg.ImportPath, cmd.Dir, cmd.Args)
 	}
 
 	bout, err := cmd.Output()
@@ -212,7 +222,8 @@ func (pkg *Package) gitGetTagLatest() (tag string, err error) {
 	cmd.Dir = pkg.FullPath
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] gitGetTagLatest %s >>> %s %s\n",
+			pkg.ImportPath, cmd.Dir, cmd.Args)
 	}
 
 	bout, err = cmd.Output()
@@ -269,13 +280,15 @@ func (pkg *Package) gitInstall() (err error) {
 func (pkg *Package) gitRemoteChange(newPkg *Package) (err error) {
 	//nolint:gas
 	cmd := exec.Command("git", "remote", "remove", pkg.RemoteName)
-	if Debug >= DebugL1 {
-		fmt.Println(">>>", cmd.Args)
-	}
 	cmd.Dir = pkg.FullPath
 	cmd.Stdout = defStdout
 	cmd.Stderr = defStderr
 
+	if Debug >= DebugL1 {
+		fmt.Printf("[PKG] gitRemoteChange %s >>> %s %s\n",
+			pkg.ImportPath, cmd.Dir, cmd.Args)
+	}
+
 	err = cmd.Run()
 	if err != nil {
 		fmt.Fprintln(defStderr, "gitRemoteChange:", err)
@@ -288,7 +301,8 @@ func (pkg *Package) gitRemoteChange(newPkg *Package) (err error) {
 	cmd.Stderr = defStderr
 
 	if Debug >= DebugL1 {
-		fmt.Printf(">>> %s %s\n", cmd.Dir, cmd.Args)
+		fmt.Printf("[PKG] gitRemoteChange %s >>> %s %s\n",
+			pkg.ImportPath, cmd.Dir, cmd.Args)
 	}
 
 	err = cmd.Run()
diff --git a/package_test.go b/package_test.go
index 17eaa84..9492bd0 100644
--- a/package_test.go
+++ b/package_test.go
@@ -514,11 +514,13 @@ func testPackageString(t *testing.T) {
 		pkg: testGitPkgCur,
 		exp: `
 [package "github.com/shuLhan/beku_test"]
+     FullPath = ` + filepath.Join(testEnv.dirSrc, testGitRepo) + `
+     ScanPath = ` + filepath.Join(testEnv.dirSrc, testGitRepo) + `
           VCS = git
    RemoteName = origin
     RemoteURL = https://` + testGitRepo + `
-     ScanPath = ` + filepath.Join(testEnv.dirSrc, testGitRepo) + `
       Version = v0.2.0
+  VersionNext = c9f69fb
         IsTag = true
          Deps = []
    RequiredBy = []