Merge branch 'development'

Author: 1minds3t

.gitignore

@@ -78,3 +78,4 @@ KEYS
 # Lock files
 *.lock
 
+branch_diffs/

omnipkg/common_utils.py

@@ -119,6 +119,68 @@ def sync_context_to_runtime():
         # Exit because a failed sync is a fatal error for the script's logic.
         sys.exit(1)
 
+def ensure_script_is_running_on_version(required_version: str):
+    """
+    A declarative guard placed at the start of a script. It ensures the script is
+    running on a specific Python version. If not, it uses the omnipkg API to
+    find the target interpreter and relaunches the script using os.execve.
+    """
+    major, minor = map(int, required_version.split('.'))
+
+    # If we are already running on the correct version, we're done.
+    if sys.version_info[:2] == (major, minor):
+        return
+
+    # This guard prevents infinite relaunch loops if something goes horribly wrong.
+    if os.environ.get('OMNIPKG_RELAUNCHED') == '1':
+        print(f"❌ FATAL ERROR: Relaunch attempted, but still not on Python {required_version}. Aborting.")
+        sys.exit(1)
+
+    print('\n' + '=' * 80)
+    print(_('  🚀 AUTOMATIC CONTEXT RELAUNCH REQUIRED'))
+    print('=' * 80)
+    print(_('   - Script requires:   Python {}').format(required_version))
+    print(_('   - Currently running: Python {}.{}').format(sys.version_info.major, sys.version_info.minor))
+    print(_('   - Relaunching into the correct context...'))
+
+    try:
+        # We must import the core late to avoid bootstrap circular dependencies
+        from omnipkg.core import ConfigManager, omnipkg as OmnipkgCore
+        
+        cm = ConfigManager(suppress_init_messages=True)
+        pkg_instance = OmnipkgCore(config_manager=cm)
+
+        # Use omnipkg's brain to find the interpreter path
+        target_exe_path = pkg_instance.interpreter_manager.config_manager.get_interpreter_for_version(required_version)
+
+        # If it's not managed, try to adopt it automatically
+        if not target_exe_path or not target_exe_path.exists():
+            print(_('   -> Target interpreter not yet managed. Attempting to adopt...'))
+            if pkg_instance.adopt_interpreter(required_version) != 0:
+                 raise RuntimeError(f"Failed to adopt required Python version {required_version}")
+            target_exe_path = pkg_instance.interpreter_manager.config_manager.get_interpreter_for_version(required_version)
+            if not target_exe_path or not target_exe_path.exists():
+                raise RuntimeError(f"Could not find Python {required_version} even after adoption.")
+
+        print(_('   ✅ Target interpreter found at: {}').format(target_exe_path))
+
+        # Set the guard variable for the new process to prevent loops
+        new_env = os.environ.copy()
+        new_env['OMNIPKG_RELAUNCHED'] = '1'
+        
+        # This is the key: os.execve REPLACES the current process with a new one.
+        # It does not return. The script starts over from the top, but inside the correct Python.
+        os.execve(str(target_exe_path), [str(target_exe_path)] + sys.argv, new_env)
+
+    except Exception as e:
+        print('\n' + '-' * 80)
+        print('   ❌ FATAL ERROR during context relaunch.')
+        print(f'   -> Error: {e}')
+        import traceback
+        traceback.print_exc()
+        print('-' * 80)
+        sys.exit(1)
+
 def run_script_in_omnipkg_env(command_list, streaming_title):
     """
     A centralized utility to run a command in a fully configured omnipkg environment.

omnipkg/core.py

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omnipkg"
-version = "1.4.2"  # <-- THE NEW LEGENDARY VERSION
+version = "1.4.3" 
 authors = [
   { name = "1minds3t", email = "[email protected]" },
 ]

omnipkg/loader.py

@@ -1,12 +1,5 @@
 import sys
 import os
-
-if sys.version_info[:2] == (3, 9):
-    print("SKIPPED: The rich switching test is currently unstable on Python 3.9.")
-    sys.exit(0)
-
-import sys
-import os
 from pathlib import Path
 import json
 import subprocess
@@ -153,126 +146,86 @@ def create_test_bubbles(config_manager):
 
 def test_python_import(expected_version: str, config_manager, is_bubble: bool):
     print(_('   🔧 Testing import of version {}...').format(expected_version))
-    # FIX: Extract config dict from config_manager
     config = config_manager.config
-    config_json_str = json.dumps(config)
-    
-    test_script_content = f'''\
+    # We must pass the project root to the subprocess so it can find the `omnipkg` source
+    project_root_str = str(Path(__file__).resolve().parent.parent)
+
+    # --- THIS IS THE NEW, ISOLATED TEST RUNNER ---
+    # We create a self-contained script to run in a pristine, isolated subprocess.
+    test_script_content = f"""
 import sys
-import importlib
-from importlib.metadata import version, PackageNotFoundError
-from pathlib import Path
 import json
+import traceback
+from pathlib import Path
 
-# Ensure omnipkg's root is in sys.path for importing its modules (e.g., omnipkg.loader)
-sys.path.insert(0, r"{Path(__file__).resolve().parents[1].parent}")
+# Add the project root to the path to find the omnipkg library
+sys.path.insert(0, r'{project_root_str}')
 
-from omnipkg.loader import omnipkgLoader
+try:
+    from omnipkg.loader import omnipkgLoader
+    from importlib.metadata import version
 
-# omnipkg.core.ConfigManager is also imported in subprocess for omnipkgLoader if config is passed
-def test_import_and_version():
-    target_package_spec = "rich=={expected_version}"
-    
-    # Load config in the subprocess
-    subprocess_config = json.loads('{config_json_str}')
+    # Load the config passed from the main test script
+    config = json.loads('{json.dumps(config)}')
+    is_bubble = {is_bubble}
+    expected_version = "{expected_version}"
+    target_spec = f"rich=={{expected_version}}"
 
-    # If it's the main environment test, we don't use the loader context for explicit switching,
-    # just import directly from the system state.
-    if not {is_bubble}: # Use the boolean value directly
-        try:
-            actual_version = version('rich')
-            expected_version = "{expected_version}"
-            assert actual_version == expected_version, f"Version mismatch! Expected {{expected_version}}, got {{actual_version}}"
-            print(f"✅ Imported and verified version {{actual_version}}")
-        except PackageNotFoundError:
-            print(f"❌ Test failed: Package 'rich' not found in main environment.", file=sys.stderr)
-            sys.exit(1)
-        except AssertionError as e:
-            print(f"❌ Test failed: {{e}}", file=sys.stderr)
-            sys.exit(1)
-        except Exception as e:
-            print(f"❌ An unexpected error occurred in main env test: {{e}}", file=sys.stderr)
-            sys.exit(1)
-        return
-
-    # For bubble tests, use the omnipkgLoader context manager
-    try:
-        with omnipkgLoader(target_package_spec, config=subprocess_config):
-            # Inside this block, the specific 'rich' version should be active
+    if is_bubble:
+        # For bubble tests, activate the loader
+        with omnipkgLoader(target_spec, config=config):
             import rich
             actual_version = version('rich')
-            expected_version = "{expected_version}"
             assert actual_version == expected_version, f"Version mismatch! Expected {{expected_version}}, got {{actual_version}}"
             print(f"✅ Imported and verified version {{actual_version}}")
-    except PackageNotFoundError:
-        print(f"❌ Test failed: Package 'rich' not found in bubble context '{{target_package_spec}}'.", file=sys.stderr)
-        sys.exit(1)
-    except AssertionError as e:
-        print(f"❌ Test failed: {{e}}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"❌ An unexpected error occurred activating/testing bubble '{{target_package_spec}}': {{e}}", file=sys.stderr)
-        import traceback
-        traceback.print_exc(file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    test_import_and_version()
-'''
+    else:
+        # For the main environment, just import directly
+        import rich
+        actual_version = version('rich')
+        assert actual_version == expected_version, f"Version mismatch! Expected {{expected_version}}, got {{actual_version}}"
+        print(f"✅ Imported and verified version {{actual_version}}")
+
+except Exception as e:
+    print(f"❌ TEST FAILED: {{e}}", file=sys.stderr)
+    traceback.print_exc(file=sys.stderr)
+    sys.exit(1)
+"""
 
-    site_packages = Path(config['site_packages_path'])
-    main_rich_dir = site_packages / 'rich'
-    main_rich_dist = next(site_packages.glob('rich-*.dist-info'), None)
-    cloaked_paths_by_test_harness = []
     temp_script_path = None
-
     try:
-        if is_bubble:
-            if main_rich_dir.exists():
-                cloak_path = main_rich_dir.with_name(_('rich.{}test_harness_cloaked').format(int(time.time() * 1000)))
-                shutil.move(main_rich_dir, cloak_path)
-                cloaked_paths_by_test_harness.append((main_rich_dir, cloak_path))
-            
-            if main_rich_dist and main_rich_dist.exists():
-                cloak_path = main_rich_dist.with_name(_('{}.{}test_harness_cloaked').format(main_rich_dist.name, int(time.time() * 1000)))
-                shutil.move(main_rich_dist, cloak_path)
-                cloaked_paths_by_test_harness.append((main_rich_dist, cloak_path))
-
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        # Write the mini-script to a temporary file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8') as f:
             f.write(test_script_content)
             temp_script_path = f.name
 
+        # Get the correct python executable from the config
         python_exe = config.get('python_executable', sys.executable)
 
-        result = subprocess.run([python_exe, temp_script_path], capture_output=True, text=True, timeout=60)
+        # Execute the mini-script in ISOLATED MODE
+        cmd = [python_exe, '-I', temp_script_path]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=90)
 
         if result.returncode == 0:
-            print(_('      └── {}').format(result.stdout.strip()))
+            print(f"      └── {result.stdout.strip()}")
             return True
         else:
-            print(_('   ❌ Subprocess FAILED for version {}:').format(expected_version))
-            print(_('      STDERR: {}').format(result.stderr.strip()))
+            print(f"   ❌ Subprocess FAILED for version {expected_version}:")
+            # Print stderr first as it contains the real traceback from the subprocess
+            print(f"      STDERR: {result.stderr.strip()}")
+            if result.stdout.strip():
+                 print(f"      STDOUT: {result.stdout.strip()}")
             return False
 
-    except subprocess.CalledProcessError as e:
-        print(_('   ❌ Subprocess FAILED for version {}:').format(expected_version))
-        print(_('      STDERR: {}').format(e.stderr.strip()))
+    except Exception as e:
+        print(f'   ❌ An unexpected error occurred while running the test subprocess: {e}')
         return False
 
     finally:
-        # Restore cloaked paths in reverse order
-        for original, cloaked in reversed(cloaked_paths_by_test_harness):
-            if cloaked.exists():
-                if original.exists():
-                    shutil.rmtree(original, ignore_errors=True)
-                try:
-                    shutil.move(cloaked, original)
-                except Exception as e:
-                    print(_('   ⚠️  Test harness failed to restore {} from {}: {}').format(original.name, cloaked.name, e))
-        
+        # Ensure the temporary script is always cleaned up
         if temp_script_path and os.path.exists(temp_script_path):
             os.unlink(temp_script_path)
-
+            
 def restore_install_strategy(config_manager, original_strategy):
     """Restore the original install strategy"""
     if original_strategy != 'stable-main':
@@ -337,13 +290,20 @@ def run_comprehensive_test():
             omnipkg_core = OmnipkgCore(config_manager)
             site_packages = Path(config_manager.config['site_packages_path'])
 
-            # Clean up test bubbles
-            for bubble in omnipkg_core.multiversion_base.glob('rich-*'):
-                if bubble.is_dir():
-                    print(_('   🧹 Removing test bubble: {}').format(bubble.name))
-                    shutil.rmtree(bubble, ignore_errors=True)
-            
-            # Clean up cloaked packages
+            # --- START OF THE FIX ---
+            # Instead of manually deleting directories, use the omnipkg API
+            # to perform a clean uninstall that also updates the knowledge base.
+
+            print(_('   🧹 Cleaning up test bubbles via omnipkg API...'))
+            specs_to_uninstall = [f'rich=={v}' for v in BUBBLE_VERSIONS_TO_TEST]
+            if specs_to_uninstall:
+                # Uninstall all bubbles in one go. The `install_type='bubble'`
+                # ensures we only target bubbles and don't touch the active version.
+                omnipkg_core.smart_uninstall(specs_to_uninstall, force=True, install_type='bubble')
+
+            # --- END OF THE FIX ---
+
+            # Clean up any residual cloaked packages (this is still good practice)
             for cloaked in site_packages.glob('rich.*_omnipkg_cloaked*'):
                 print(_('   🧹 Removing residual cloaked: {}').format(cloaked.name))
                 shutil.rmtree(cloaked, ignore_errors=True)

omnipkg/package_meta_builder.py

@@ -2,12 +2,31 @@
 import os
 from pathlib import Path
 
+# --- PROJECT PATH SETUP ---
+# This must come first so Python can find your modules.
 project_root = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(project_root))
 
-from omnipkg.common_utils import sync_context_to_runtime
+# --- DETECT CURRENT PYTHON VERSION ---
+CURRENT_PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
+print(f"🐍 Detected current Python version: {CURRENT_PYTHON_VERSION}")
+
+# --- BOOTSTRAP SECTION ---
+# Import ONLY the necessary utilities for the bootstrap process.
+from omnipkg.common_utils import ensure_python_or_relaunch, sync_context_to_runtime
+
+# 1. Declarative script guard: Ensures this script runs on Python 3.9.
+#    If not, it will relaunch this script with the correct interpreter and exit.
+# 1. Declarative script guard: Ensures this script runs on the detected Python version.
+#    If not, it will relaunch the script with the correct interpreter and exit.
+if os.environ.get('OMNIPKG_RELAUNCHED') != '1':
+    ensure_python_or_relaunch(CURRENT_PYTHON_VERSION)
+
+# 2. Sync guard: Now that we are GUARANTEED to be running on the correct
+#    interpreter, we sync omnipkg's config to match this runtime.
 sync_context_to_runtime()
 
+
 import sys
 import os
 from pathlib import Path
@@ -142,6 +161,11 @@ def setup_environment():
         print(_('   ❌ Failed to install main environment UV version'))
         return None, original_strategy
 
+    # --- THIS IS THE FIX ---
+    # Tell omnipkg to update its knowledge about the package we just installed.
+    force_omnipkg_rescan(omnipkg_core, 'uv')
+    # --- END OF THE FIX ---
+    
     print(_('✅ Environment prepared'))
     return config_manager, original_strategy
 
@@ -160,6 +184,18 @@ def create_test_bubbles(config_manager):
 
     return BUBBLE_VERSIONS_TO_TEST
 
+def force_omnipkg_rescan(omnipkg_core, package_name):
+    """Tells omnipkg to forcibly rescan a specific package's metadata."""
+    print(f'   🧠 Forcing omnipkg KB rebuild for {package_name}...')
+    try:
+        # We'll use our new internal method directly for the test
+        omnipkg_core.rebuild_package_kb([package_name])
+        print(f'   ✅ KB rebuild for {package_name} complete.')
+        return True
+    except Exception as e:
+        print(f'   ❌ KB rebuild for {package_name} failed: {e}')
+        return False
+
 def inspect_bubble_structure(bubble_path):
     """Prints a summary of the bubble's directory structure for verification."""
     print(_('   🔍 Inspecting bubble structure: {}').format(bubble_path.name))
@@ -312,6 +348,8 @@ def run_comprehensive_test():
             print(_('   📦 Restoring main environment: uv=={}').format(MAIN_UV_VERSION))
             pip_uninstall_uv()
             pip_install_uv(MAIN_UV_VERSION)
+
+            force_omnipkg_rescan(omnipkg_core, 'uv')
 
             # Restore original install strategy if it was changed
             if original_strategy and original_strategy != 'stable-main':