Implement OSGi semantic versioning for dependency version ranges

- Add computeUpperBound method that follows OSGi semantic versioning
- Preserve existing upper bounds when major version hasn't changed
- Automatically add upper bounds (next major) when none exist
- Update copilot instructions with OSGi semantic versioning concepts

Co-authored-by: laeubi <[email protected]>

Author: Copilot

.github/copilot-instructions.md

@@ -82,6 +82,28 @@ mvn clean verify -Dmaven.repo.local=$WORKSPACE/.m2/repository \
 
 **Docs:** `docs/API_Tools.md` for comprehensive API Tools documentation.
 
+## OSGi Semantic Versioning
+
+**PDE follows OSGi semantic versioning principles** (https://docs.osgi.org/whitepaper/semantic-versioning/):
+
+**Version Format:** `major.minor.micro.qualifier`
+- **Major:** Breaking changes (incompatible API changes)
+- **Minor:** Backward-compatible API additions
+- **Micro:** Backward-compatible bug fixes
+- **Qualifier:** Build metadata (e.g., timestamps, commit hashes)
+
+**Version Ranges for Dependencies:**
+- Use version ranges to specify compatible dependency versions
+- **Inclusive lower bound:** `[1.2.3,2.0.0)` includes 1.2.3
+- **Exclusive upper bound:** `[1.2.3,2.0.0)` excludes 2.0.0
+- **Best practice:** Lower bound inclusive, upper bound at next major (exclusive)
+  - Example: For version `1.2.3`, use `[1.2.3,2.0.0)` to accept any 1.x version
+  - Example: For version `2.5.0`, use `[2.5.0,3.0.0)` to accept any 2.x version
+
+**Why exclude next major?** Major version changes indicate breaking changes, so dependencies should not automatically upgrade across major versions.
+
+**PDE Support:** PDE manifest editor and dialogs should help users create proper version ranges following these principles when adding or updating bundle/package dependencies.
+
 ## Key Notes
 
 **Tycho:** Eclipse-specific Maven extension managing OSGi dependencies, P2 repos, Eclipse metadata (MANIFEST.MF, plugin.xml, feature.xml).

ui/org.eclipse.pde.ui/src/org/eclipse/pde/internal/ui/parts/PluginVersionPart.java

@@ -82,7 +82,10 @@ protected void buttonSelected(Button button, int index) {
 			IStructuredSelection selection = getTableViewer().getStructuredSelection();
 			if (selection.size() == 1) {
 				String version = getVersion(selection.getFirstElement());
-				setVersion(version, ""); //$NON-NLS-1$
+				// Compute upper bound following OSGi semantic versioning
+				// Preserve existing upper bound if present and major version hasn't changed
+				String upperBound = computeUpperBound(version, getCurrentUpperBound());
+				setVersion(version, upperBound);
 			} else {
 				// plug-ins come back in a sorted order so we assume min/max
 				String minVersion;
@@ -105,7 +108,9 @@ protected void buttonSelected(Button button, int index) {
 					maxVersion = poMax.getVersion();
 
 				}
-				setVersion(minVersion, maxVersion);
+				// Compute upper bound based on max version following OSGi semantic versioning
+				String upperBound = computeUpperBound(maxVersion, getCurrentUpperBound());
+				setVersion(minVersion, upperBound);
 			}
 		}
 
@@ -117,6 +122,53 @@ private String getVersion(Object firstElement) {
 			PackageObject po = (PackageObject) firstElement;
 			return po.getVersion();
 		}
+
+		/**
+		 * Gets the current upper bound from the existing version range, if any.
+		 * 
+		 * @return the current upper bound version, or null if none exists
+		 */
+		private Version getCurrentUpperBound() {
+			if (fVersionRange != null) {
+				return fVersionRange.getRight();
+			}
+			return null;
+		}
+
+		/**
+		 * Computes the upper bound for a version range following OSGi semantic versioning.
+		 * If an existing upper bound is present, it will be adjusted based on the new lower bound's major version.
+		 * Otherwise, a new upper bound excluding the next major version is created.
+		 * 
+		 * @param newLowerBound the new lower bound version
+		 * @param existingUpperBound the existing upper bound (may be null)
+		 * @return the upper bound version (next major version as a string)
+		 */
+		private String computeUpperBound(String newLowerBound, Version existingUpperBound) {
+			try {
+				Version lowerVersion = Version.parseVersion(newLowerBound);
+				int newMajor = lowerVersion.getMajor();
+				
+				if (existingUpperBound != null) {
+					// Existing upper bound present - adjust it if major version changed
+					int existingUpperMajor = existingUpperBound.getMajor();
+					
+					// If the new lower bound has the same major version as the existing upper bound,
+					// keep the existing upper bound
+					if (newMajor < existingUpperMajor) {
+						return existingUpperBound.toString();
+					}
+					// If the new lower bound's major version changed, update to next major
+				}
+				
+				// No existing upper bound or major version changed - compute next major version
+				Version nextMajor = new Version(newMajor + 1, 0, 0);
+				return nextMajor.toString();
+			} catch (IllegalArgumentException e) {
+				// If version parsing fails, return empty string to maintain backward compatibility
+				return ""; //$NON-NLS-1$
+			}
+		}
 	}
 
 	private static class PluginVersionContentProvider implements IStructuredContentProvider {