titan-cli 0.4.3__tar.gz → 0.4.5__tar.gz

{titan_cli-0.4.3 → titan_cli-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: titan-cli
-Version: 0.4.3
+Version: 0.4.5
 Summary: Modular development tools orchestrator - Streamline your workflows with AI integration and intuitive terminal UI
 License: MIT
 License-File: LICENSE

{titan_cli-0.4.3 → titan_cli-0.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "titan-cli"
-version = "0.4.3"
+version = "0.4.5"
 description = "Modular development tools orchestrator - Streamline your workflows with AI integration and intuitive terminal UI"
 authors = ["MasOrange Apps Team <apps-management-stores@masorange.es>"]
 readme = "README.md"

{titan_cli-0.4.3 → titan_cli-0.4.5}/titan_cli/cli.py

@@ -4,14 +4,19 @@ Titan CLI - Main CLI application
 Combines all tool commands into a single CLI interface.
 """
 import os
-import subprocess
 import sys
 import typer
 
 from titan_cli import __version__
 from titan_cli.messages import msg
 from titan_cli.ui.tui import launch_tui
-from titan_cli.utils.autoupdate import check_for_updates, update_core, update_plugins
+from titan_cli.utils.autoupdate import (
+    check_for_updates,
+    get_installed_version,
+    meets_target_version,
+    update_core,
+    update_plugins,
+)
 from titan_cli.core.logging import setup_logging, get_logger
 
 
@@ -86,7 +91,7 @@ def main(
 
                     # Step 1: update core
                     typer.echo("⏳ Updating Titan CLI...")
-                    core_result = update_core()
+                    core_result = update_core(target_version=latest)
 
                     if not core_result["success"]:
                         logger.error("update_core_failed", error=core_result["error"])
@@ -116,12 +121,30 @@ def main(
                     if not plugins_result.get("skipped"):
                         typer.echo("✅ Plugins updated")
 
-                    logger.info("update_successful", version=installed_version)
-                    typer.echo()
-                    typer.echo("🔄 Relaunching Titan with new version...")
-                    typer.echo()
+                    final_version = get_installed_version()
+                    if not final_version or not meets_target_version(final_version, latest):
+                        logger.error(
+                            "update_final_version_check_failed",
+                            expected=latest,
+                            installed=final_version,
+                        )
+                        typer.echo(
+                            "❌ Failed to verify Titan CLI after plugin update: "
+                            f"installed version is {final_version or 'unknown'}, "
+                            f"expected at least {latest}"
+                        )
+                        typer.echo()
+                        typer.echo("   Please update manually:")
+                        typer.echo("     pipx upgrade --force titan-cli")
+                        typer.echo("     pipx upgrade --include-injected titan-cli")
+                        sys.exit(1)
 
-                    subprocess.run(["titan"] + sys.argv[1:], shell=False, check=False)
+                    logger.info("update_successful", version=final_version)
+                    typer.echo()
+                    typer.echo(
+                        "✅ Update complete. Please run `titan` again to use "
+                        f"v{final_version}."
+                    )
                     sys.exit(0)
                 else:
                     logger.info("update_skipped")

{titan_cli-0.4.3 → titan_cli-0.4.5}/titan_cli/utils/autoupdate.py

@@ -1,11 +1,15 @@
 """Auto-update utility for Titan CLI."""
 
 import os
+import re
+import shutil
 import sys
 import subprocess
 from typing import Dict, Optional
 from pathlib import Path
 
+from packaging import version
+
 from titan_cli import __version__
 
 
@@ -99,7 +103,7 @@ def check_for_updates() -> Dict[str, any]:
     return result
 
 
-def update_core() -> Dict[str, any]:
+def update_core(target_version: Optional[str] = None) -> Dict[str, any]:
     """
     Upgrade the titan-cli core package.
 
@@ -116,6 +120,13 @@ def update_core() -> Dict[str, any]:
     if mock_version:
         if os.environ.get("TITAN_MOCK_CORE_FAIL"):
             return {"success": False, "method": None, "installed_version": None, "error": "Mock core failure"}
+        if target_version and not _meets_target_version(mock_version, target_version):
+            return {
+                "success": False,
+                "method": None,
+                "installed_version": mock_version,
+                "error": _target_version_error(mock_version, target_version),
+            }
         return {"success": True, "method": "pipx", "installed_version": mock_version, "error": None}
 
     result = {
@@ -136,11 +147,14 @@ def update_core() -> Dict[str, any]:
         )
 
         if proc.returncode == 0:
-            installed_version = _get_installed_version_runtime() or _get_installed_version_pipx()
-            if installed_version:
+            installed_version = get_installed_version()
+            if installed_version and _is_expected_installed_version(installed_version, target_version):
                 result["success"] = True
                 result["method"] = "pipx"
                 result["installed_version"] = installed_version
+            elif installed_version:
+                result["installed_version"] = installed_version
+                result["error"] = _target_version_error(installed_version, target_version)
             else:
                 result["error"] = "Could not verify installed version"
             return result
@@ -161,11 +175,14 @@ def update_core() -> Dict[str, any]:
         )
 
         if proc.returncode == 0:
-            installed_version = _get_installed_version_runtime() or _get_installed_version_pip()
-            if installed_version:
+            installed_version = get_installed_version()
+            if installed_version and _is_expected_installed_version(installed_version, target_version):
                 result["success"] = True
                 result["method"] = "pip"
                 result["installed_version"] = installed_version
+            elif installed_version:
+                result["installed_version"] = installed_version
+                result["error"] = _target_version_error(installed_version, target_version)
             else:
                 result["error"] = "Could not verify installed version"
         else:
@@ -177,6 +194,40 @@ def update_core() -> Dict[str, any]:
         return result
 
 
+def get_installed_version() -> Optional[str]:
+    """Get the Titan version that is visible to the user after installation."""
+    return (
+        _get_active_titan_version()
+        or _get_installed_version_pipx()
+        or _get_installed_version_pip()
+        or _get_installed_version_runtime()
+    )
+
+
+def _get_active_titan_version() -> Optional[str]:
+    """Get the version reported by the `titan` command currently on PATH."""
+    titan_command = shutil.which("titan")
+    if not titan_command:
+        return None
+
+    try:
+        proc = subprocess.run(
+            [titan_command, "version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if proc.returncode != 0:
+            return None
+
+        match = re.search(r"v?(\d+(?:\.\d+)+(?:[-+\.a-zA-Z0-9]*)?)", proc.stdout.strip())
+        if match:
+            return match.group(1)
+    except Exception:
+        pass
+    return None
+
+
 def update_plugins() -> Dict[str, any]:
     """
     Upgrade injected plugins via pipx.
@@ -287,6 +338,49 @@ def _get_installed_version_pip() -> Optional[str]:
     return None
 
 
+def _is_newer_installed_version(installed_version: str) -> bool:
+    """Return True when the installed version is newer than the running one."""
+    try:
+        return version.parse(installed_version) > version.parse(__version__)
+    except Exception:
+        return installed_version != __version__
+
+
+def _is_expected_installed_version(
+    installed_version: str,
+    target_version: Optional[str] = None,
+) -> bool:
+    """Return True when installed version satisfies the expected post-update state."""
+    if target_version:
+        return _meets_target_version(installed_version, target_version)
+    return _is_newer_installed_version(installed_version)
+
+
+def _meets_target_version(installed_version: str, target_version: str) -> bool:
+    """Return True when installed version is at least the requested target."""
+    try:
+        return version.parse(installed_version) >= version.parse(target_version)
+    except Exception:
+        return installed_version == target_version
+
+
+def meets_target_version(installed_version: str, target_version: str) -> bool:
+    """Return True when installed version is at least the requested target."""
+    return _meets_target_version(installed_version, target_version)
+
+
+def _target_version_error(
+    installed_version: str,
+    target_version: Optional[str] = None,
+) -> str:
+    """Build a precise error for a failed post-update version check."""
+    if target_version:
+        return (
+            f"Installed version is {installed_version}; expected at least {target_version}"
+        )
+    return f"Installed version remains at {installed_version}; update did not apply"
+
+
 def get_update_message(update_info: Dict[str, any]) -> Optional[str]:
     """
     Generate user-friendly update message.