fix: version parsing for packages with dashes, improve dry-run output

- Use xbps-uhelper for correct pkgver parsing (fixes
  visual-studio-code-insiders)
- Add update detection for already-installed VUP packages
- Show "Package already installed" vs "Dependencies already installed"

Author: AmarBego

vuru/src/core/resolve/resolver.odin

@@ -6,6 +6,7 @@ import "core:strings"
 import errors "../../core/errors"
 import index "../../core/index"
 import template "../../core/template"
+import xbps "../../core/xbps"
 import utils "../../utils"
 import config "../config"
 
@@ -14,6 +15,29 @@ is_pkg_installed :: proc(name: string) -> bool {
 	return utils.run_command_silent({"xbps-query", name}) == 0
 }
 
+// Get the installed version of a package
+// Returns empty string if not installed
+get_installed_version :: proc(name: string) -> (version: string, ok: bool) {
+	output, cmd_ok := utils.run_command_output({"xbps-query", name}, context.temp_allocator)
+	if !cmd_ok {
+		return "", false
+	}
+
+	// Parse pkgver from output
+	for line in strings.split_lines_iterator(&output) {
+		if strings.has_prefix(line, "pkgver:") {
+			value := strings.trim_space(line[7:])
+			// Use xbps-uhelper for correct parsing of packages with dashes in names
+			_, version, parse_ok := xbps.parse_pkgver(value)
+			if parse_ok {
+				return version, true
+			}
+		}
+	}
+
+	return "", false
+}
+
 // Check if package exists in official Void repos
 is_in_official_repos :: proc(name: string) -> (version: string, ok: bool) {
 	output, cmd_ok := utils.run_command_output({"xbps-query", "-R", name}, context.temp_allocator)
@@ -25,9 +49,10 @@ is_in_official_repos :: proc(name: string) -> (version: string, ok: bool) {
 	for line in strings.split_lines_iterator(&output) {
 		if strings.has_prefix(line, "pkgver:") {
 			value := strings.trim_space(line[7:])
-			// Format: name-version
-			if idx := strings.last_index(value, "-"); idx > 0 {
-				return strings.clone(value[idx + 1:], context.temp_allocator), true
+			// Use xbps-uhelper for correct parsing of packages with dashes in names
+			_, version, parse_ok := xbps.parse_pkgver(value)
+			if parse_ok {
+				return version, true
 			}
 		}
 	}
@@ -48,18 +73,35 @@ resolve_package :: proc(
 	bool,
 ) {
 	// 1. Check if already installed
-	if is_pkg_installed(name) {
-		return Resolved_Package {
-				name    = strings.clone(name, allocator),
-				source  = .Official, // Treat as satisfied (empty version = already installed)
-				version = "",
-				depth   = depth,
-			}, true
-	}
+	installed_ver, is_installed := get_installed_version(name)
 
 	// 2. Check VUP index for binary
 	if vup_pkg, ok := index.index_get_package(idx, name); ok {
 		if url, url_ok := vup_pkg.repo_urls[arch]; url_ok {
+			// If installed, check if VUP has a newer version
+			if is_installed {
+				if xbps.version_greater_than(vup_pkg.version, installed_ver, utils.run_command) {
+					// VUP has a newer version - mark for upgrade
+					return Resolved_Package {
+							name = strings.clone(name, allocator),
+							source = .VUP,
+							version = strings.clone(vup_pkg.version, allocator),
+							repo_url = strings.clone(url, allocator),
+							category = strings.clone(vup_pkg.category, allocator),
+							depth = depth,
+						},
+						true
+				} else {
+					// Already up to date
+					return Resolved_Package {
+							name    = strings.clone(name, allocator),
+							source  = .Official, // Treat as satisfied (empty version = already installed)
+							version = "",
+							depth   = depth,
+						}, true
+				}
+			}
+			// Not installed - install from VUP
 			return Resolved_Package {
 					name = strings.clone(name, allocator),
 					source = .VUP,
@@ -72,7 +114,17 @@ resolve_package :: proc(
 		}
 	}
 
-	// 3. Check official Void repos
+	// 3. Already installed but not in VUP index - satisfied
+	if is_installed {
+		return Resolved_Package {
+				name    = strings.clone(name, allocator),
+				source  = .Official, // Treat as satisfied (empty version = already installed)
+				version = "",
+				depth   = depth,
+			}, true
+	}
+
+	// 4. Check official Void repos
 	if version, ok := is_in_official_repos(name); ok {
 		return Resolved_Package {
 				name = strings.clone(name, allocator),
@@ -83,7 +135,7 @@ resolve_package :: proc(
 			true
 	}
 
-	// 4. Not found anywhere - return false, no allocations made
+	// 5. Not found anywhere - return false, no allocations made
 	return {}, false
 }
 
@@ -97,7 +149,7 @@ resolve_deps :: proc(
 	Resolution,
 	bool,
 ) {
-	res := resolution_make(allocator)
+	res := resolution_make(target, allocator)
 
 	arch, arch_ok := config.get_arch()
 	if !arch_ok {
@@ -235,22 +287,37 @@ fetch_and_parse_template :: proc(
 resolution_print :: proc(r: ^Resolution) {
 	fmt.println()
 
-	// Separate VUP and official packages
-	vup_pkgs: [dynamic]string
-	official_pkgs: [dynamic]string
+	// Check if the target package itself is already installed
+	target_satisfied := false
+	for name in r.satisfied {
+		if name == r.target {
+			target_satisfied = true
+			break
+		}
+	}
+
+	// If target is satisfied and nothing to install/build, just say package is installed
+	if target_satisfied && len(r.to_install) == 0 && len(r.to_build) == 0 {
+		fmt.printf("Package already installed: %s\n", r.target)
+		return
+	}
 
+	// Separate VUP packages and official dependencies to install
+	vup_pkgs: [dynamic]string
+	official_deps_to_install: [dynamic]string
 
 	for pkg in r.to_install {
 		if pkg.source == .VUP {
 			append(&vup_pkgs, pkg.name)
 		} else {
-			append(&official_pkgs, pkg.name)
+			append(&official_deps_to_install, pkg.name)
 		}
 	}
 
+	// VUP packages to install
 	if len(vup_pkgs) > 0 {
 		fmt.printf("VUP packages (%d):\n", len(vup_pkgs))
-		fmt.print(" ")
+		fmt.print("  ")
 		for name, i in vup_pkgs {
 			if i > 0 {
 				fmt.print(" ")
@@ -261,46 +328,59 @@ resolution_print :: proc(r: ^Resolution) {
 		fmt.println()
 	}
 
-	if len(official_pkgs) > 0 {
-		fmt.printf("Official deps (%d):\n", len(official_pkgs))
-		fmt.print(" ")
-		for name, i in official_pkgs {
+	// Build from source
+	if len(r.to_build) > 0 {
+		fmt.printf("Build from source (%d):\n", len(r.to_build))
+		fmt.print("  ")
+		for pkg, i in r.to_build {
 			if i > 0 {
 				fmt.print(" ")
 			}
-			fmt.print(name)
+			fmt.print(pkg.name)
 		}
 		fmt.println()
+		fmt.println()
 	}
 
-	if len(r.to_build) > 0 {
-		fmt.printf("Build from source (%d):\n", len(r.to_build))
-		fmt.print(" ")
-		for pkg, i in r.to_build {
+	// Dependencies to install from official repos
+	if len(official_deps_to_install) > 0 {
+		fmt.printf("Dependencies to install (%d):\n", len(official_deps_to_install))
+		fmt.print("  ")
+		for name, i in official_deps_to_install {
 			if i > 0 {
 				fmt.print(" ")
 			}
-			fmt.print(pkg.name)
+			fmt.print(name)
 		}
 		fmt.println()
 		fmt.println()
 	}
 
-	if len(r.satisfied) > 0 {
-		fmt.printf("Already installed (%d):\n", len(r.satisfied))
-		fmt.print(" ")
-		for name, i in r.satisfied {
+	// Dependencies already satisfied (exclude target)
+	deps_satisfied: [dynamic]string
+	for name in r.satisfied {
+		if name != r.target {
+			append(&deps_satisfied, name)
+		}
+	}
+
+	if len(deps_satisfied) > 0 {
+		fmt.printf("Dependencies already installed (%d):\n", len(deps_satisfied))
+		fmt.print("  ")
+		for name, i in deps_satisfied {
 			if i > 0 {
 				fmt.print(" ")
 			}
 			fmt.print(name)
 		}
 		fmt.println()
+		fmt.println()
 	}
 
+	// Missing/unresolvable
 	if len(r.missing) > 0 {
 		fmt.printf("Missing (%d):\n", len(r.missing))
-		fmt.print(" ")
+		fmt.print("  ")
 		for name, i in r.missing {
 			if i > 0 {
 				fmt.print(" ")

vuru/src/core/resolve/types.odin

@@ -1,6 +1,7 @@
 package resolve
 
 import "core:mem"
+import "core:strings"
 
 import errors "../../core/errors"
 import template "../../core/template"
@@ -26,6 +27,9 @@ Resolved_Package :: struct {
 
 // Resolution result
 Resolution :: struct {
+	// The target package being resolved
+	target:     string,
+
 	// Packages to install from binary repos (in dependency order)
 	to_install: [dynamic]Resolved_Package,
 
@@ -90,13 +94,19 @@ resolution_free :: proc(r: ^Resolution) {
 	}
 	delete(r.missing)
 
+	// Free target
+	if len(r.target) > 0 {
+		delete(r.target, r.allocator)
+	}
+
 	// Errors are temp-based views, ctx is not owned - just free the array
 	delete(r.errors)
 }
 
 // Create a new empty Resolution
-resolution_make :: proc(allocator := context.allocator) -> Resolution {
+resolution_make :: proc(target: string = "", allocator := context.allocator) -> Resolution {
 	return Resolution {
+		target = strings.clone(target, allocator) if len(target) > 0 else "",
 		to_install = make([dynamic]Resolved_Package, allocator),
 		to_build = make([dynamic]Resolved_Package, allocator),
 		satisfied = make([dynamic]string, allocator),

vuru/src/core/xbps/common.odin

@@ -5,6 +5,7 @@ import "core:strings"
 // Common utilities for XBPS operations
 
 import "core:mem"
+import "../../utils"
 
 // Type alias for command runner functions
 Command_Runner :: proc(args: []string) -> int
@@ -37,12 +38,53 @@ build_args_with_yes :: proc(
 	return result
 }
 
-// Parse "pkgname-version" format into (name, version)
+// Parse "pkgname-version" format into (name, version) using xbps-uhelper
+// This correctly handles package names with dashes (e.g., visual-studio-code-insiders-1.102.0.20250116_1)
 parse_pkgver :: proc(pkgver: string) -> (name: string, version: string, ok: bool) {
 	if len(pkgver) == 0 {
 		return "", "", false
 	}
 
+	// Use xbps-uhelper getpkgname to correctly parse the package name
+	name_output, name_ok := utils.run_command_output(
+		{"xbps-uhelper", "getpkgname", pkgver},
+		context.temp_allocator,
+	)
+	if !name_ok {
+		// Fall back to simple parsing if xbps-uhelper fails
+		return parse_pkgver_simple(pkgver)
+	}
+
+	parsed_name := strings.trim_space(name_output)
+	if len(parsed_name) == 0 {
+		return parse_pkgver_simple(pkgver)
+	}
+
+	// Use xbps-uhelper getpkgversion to correctly parse the version
+	ver_output, ver_ok := utils.run_command_output(
+		{"xbps-uhelper", "getpkgversion", pkgver},
+		context.temp_allocator,
+	)
+	if !ver_ok {
+		return parse_pkgver_simple(pkgver)
+	}
+
+	parsed_version := strings.trim_space(ver_output)
+	if len(parsed_version) == 0 {
+		return parse_pkgver_simple(pkgver)
+	}
+
+	return parsed_name, parsed_version, true
+}
+
+// Parse "pkgname-version" format into (name, version) using simple string splitting
+// NOTE: This is a fallback and does NOT work correctly for packages with dashes in their names!
+// Prefer parse_pkgver which uses xbps-uhelper for correct parsing.
+parse_pkgver_simple :: proc(pkgver: string) -> (name: string, version: string, ok: bool) {
+	if len(pkgver) == 0 {
+		return "", "", false
+	}
+
 	idx := strings.last_index(pkgver, "-")
 	if idx <= 0 || idx >= len(pkgver) - 1 {
 		return "", "", false