titan-cli 0.4.0__tar.gz → 0.4.2__tar.gz

{titan_cli-0.4.0 → titan_cli-0.4.2}/PKG-INFO

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

{titan_cli-0.4.0 → titan_cli-0.4.2}/plugins/titan-plugin-git/titan_plugin_git/clients/git_client.py

@@ -267,6 +267,12 @@ class GitClient:
         """Get list of commits in head_branch that are not in base_branch."""
         return self.commit_service.get_branch_commits(base_branch, head_branch)
 
+    def get_commits_between_refs(
+        self, base_ref: str, head_ref: str = "HEAD"
+    ) -> ClientResult[List[str]]:
+        """Get list of commits reachable from head_ref but not base_ref."""
+        return self.commit_service.get_commits_between_refs(base_ref, head_ref)
+
     def count_commits_ahead(self, base_branch: str = "develop") -> ClientResult[int]:
         """Count how many commits current branch is ahead of base branch."""
         return self.commit_service.count_commits_ahead(base_branch)
@@ -353,6 +359,10 @@ class GitClient:
         """Push to remote."""
         return self.remote_service.push(remote, branch, set_upstream, tags)
 
+    def push_tag(self, tag_name: str, remote: str = "origin") -> ClientResult[None]:
+        """Push a specific tag to remote."""
+        return self.remote_service.push_tag(tag_name, remote)
+
     def pull(
         self, remote: str = "origin", branch: Optional[str] = None
     ) -> ClientResult[None]:
@@ -406,6 +416,10 @@ class GitClient:
         """Check if a tag exists locally."""
         return self.tag_service.tag_exists(tag_name)
 
+    def remote_tag_exists(self, tag_name: str, remote: str = "origin") -> ClientResult[bool]:
+        """Check if a tag exists on a remote."""
+        return self.tag_service.remote_tag_exists(tag_name, remote)
+
     def list_tags(self) -> ClientResult[List[UIGitTag]]:
         """List all tags in the repository."""
         return self.tag_service.list_tags()

{titan_cli-0.4.0 → titan_cli-0.4.2}/plugins/titan-plugin-git/titan_plugin_git/clients/services/commit_service.py

@@ -225,6 +225,37 @@ class CommitService:
         except GitCommandError as e:
             return ClientError(error_message=str(e), error_code="COMMIT_ERROR")
 
+    @log_client_operation()
+    def get_commits_between_refs(
+        self, base_ref: str, head_ref: str = "HEAD"
+    ) -> ClientResult[List[str]]:
+        """
+        Get list of commit subjects reachable from head_ref but not base_ref.
+
+        Args:
+            base_ref: Base git reference (tag, branch, or commit SHA)
+            head_ref: Head git reference (default: HEAD)
+
+        Returns:
+            ClientResult[List[str]] with commit messages
+        """
+        try:
+            output = self.git.run_command([
+                "git", "log", f"{base_ref}..{head_ref}", "--pretty=format:%s"
+            ])
+
+            if not output:
+                return ClientSuccess(data=[], message="No commits found")
+
+            commits = [line.strip() for line in output.split("\n") if line.strip()]
+            return ClientSuccess(
+                data=commits,
+                message=f"Found {len(commits)} commits between {base_ref} and {head_ref}",
+            )
+
+        except GitCommandError as e:
+            return ClientError(error_message=str(e), error_code="COMMIT_ERROR")
+
     @log_client_operation()
     def count_commits_ahead(self, base_branch: str = "develop") -> ClientResult[int]:
         """

{titan_cli-0.4.0 → titan_cli-0.4.2}/plugins/titan-plugin-git/titan_plugin_git/clients/services/remote_service.py

@@ -71,6 +71,24 @@ class RemoteService:
         except GitCommandError as e:
             return ClientError(error_message=str(e), error_code="PUSH_ERROR")
 
+    @log_client_operation()
+    def push_tag(self, tag_name: str, remote: str = "origin") -> ClientResult[None]:
+        """
+        Push a specific tag to remote.
+
+        Args:
+            tag_name: Tag name to push
+            remote: Remote name
+
+        Returns:
+            ClientResult[None]
+        """
+        try:
+            self.git.run_command(["git", "push", remote, tag_name])
+            return ClientSuccess(data=None, message=f"Pushed tag {tag_name} to {remote}")
+        except GitCommandError as e:
+            return ClientError(error_message=str(e), error_code="PUSH_ERROR")
+
     @log_client_operation()
     def pull(
         self, remote: str = "origin", branch: Optional[str] = None

{titan_cli-0.4.0 → titan_cli-0.4.2}/plugins/titan-plugin-git/titan_plugin_git/clients/services/tag_service.py

@@ -93,6 +93,31 @@ class TagService:
         except GitCommandError as e:
             return ClientError(error_message=str(e), error_code="TAG_CHECK_ERROR")
 
+    @log_client_operation()
+    def remote_tag_exists(self, tag_name: str, remote: str = "origin") -> ClientResult[bool]:
+        """
+        Check if a tag exists on a remote.
+
+        Args:
+            tag_name: Name of the tag to check
+            remote: Remote name
+
+        Returns:
+            ClientResult[bool] with True if tag exists on the remote
+        """
+        try:
+            output = self.git.run_command(
+                ["git", "ls-remote", "--tags", remote, f"refs/tags/{tag_name}"],
+                check=False,
+            )
+            exists = bool(output.strip())
+            return ClientSuccess(
+                data=exists,
+                message=f"Tag '{tag_name}' {'exists' if exists else 'does not exist'} on {remote}",
+            )
+        except GitCommandError as e:
+            return ClientError(error_message=str(e), error_code="TAG_CHECK_ERROR")
+
     @log_client_operation()
     def list_tags(self) -> ClientResult[List[UIGitTag]]:
         """

{titan_cli-0.4.0 → titan_cli-0.4.2}/plugins/titan-plugin-github/titan_plugin_github/clients/network/gh_network.py

@@ -99,7 +99,7 @@ class GHNetwork:
             )
             return result.stdout.strip()
         except subprocess.CalledProcessError as e:
-            self._logger.debug(
+            self._logger.error(
                 "gh_command_failed",
                 subcommand=subcommand,
                 action=action,
@@ -107,7 +107,7 @@ class GHNetwork:
                 exit_code=e.returncode,
             )
             error_msg = e.stderr.strip() if e.stderr else str(e)
-            raise GitHubAPIError(msg.GitHub.API_ERROR.format(error_msg=error_msg))
+            raise GitHubAPIError(msg.GitHub.API_ERROR.format(error_msg=error_msg)) from e
         except FileNotFoundError:
             raise GitHubError(msg.GitHub.CLI_NOT_FOUND)
         except Exception as e:

{titan_cli-0.4.0 → titan_cli-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "titan-cli"
-version = "0.4.0"
+version = "0.4.2"
 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.0 → titan_cli-0.4.2}/titan_cli/ai/dependencies.py

@@ -7,7 +7,7 @@ import subprocess
 import sys
 from dataclasses import dataclass
 
-from titan_cli.core.plugins.community import is_running_in_pipx
+from titan_cli.core.plugins.community_sources import is_running_in_pipx
 
 
 @dataclass(frozen=True)

{titan_cli-0.4.0 → titan_cli-0.4.2}/titan_cli/core/config.py

@@ -1,6 +1,9 @@
 # core/config.py
+from copy import deepcopy
+import hashlib
 from pathlib import Path
-from typing import Optional, List
+import re
+from typing import List, Optional
 import tomli
 from .models import TitanConfigModel
 from .migrations import MigrationManager
@@ -10,6 +13,7 @@ from .secrets import SecretManager
 from .errors import ConfigParseError, ConfigWriteError
 from .utils import find_project_root
 from .logging import get_logger
+from .plugins.community_sources import PluginChannel
 
 logger = get_logger(__name__)
 
@@ -18,10 +22,7 @@ class TitanConfig:
 
     GLOBAL_CONFIG = Path.home() / ".titan" / "config.toml"
     global_migration_manager = MigrationManager()
-    project_migration_manager = MigrationManager(
-        migrations=[],
-        target_version="legacy",
-    )
+    project_migration_manager = MigrationManager()
 
     def __init__(
         self,
@@ -38,6 +39,7 @@ class TitanConfig:
         self._active_project_path = None  # Set by load()
         self._workflow_registry = None  # Set by load()
         self._plugin_warnings = []
+        self._plugin_sync_events = []
 
         # Use custom global config path if provided (for testing), otherwise use default
         self._global_config_path = global_config_path or self.GLOBAL_CONFIG
@@ -69,10 +71,7 @@ class TitanConfig:
         self.project_config_path = self._find_project_config(project_root)
 
         # Load project config if it exists
-        self.project_config = self._load_and_migrate_toml(
-            self.project_config_path,
-            migration_manager=self.project_migration_manager,
-        )
+        self.project_config = self._load_toml(self.project_config_path)
 
         # Merge and validate final config
         merged = self._merge_configs(self.global_config, self.project_config)
@@ -87,6 +86,7 @@ class TitanConfig:
             self.registry.reset()
             self.registry.initialize_plugins(config=self, secrets=self.secrets)
             self._plugin_warnings = self.registry.list_failed()
+            self._plugin_sync_events = self.registry.list_sync_events()
 
         # Re-initialize WorkflowRegistry using project root
         project_step_source = ProjectStepSource(project_root=project_root)
@@ -133,6 +133,7 @@ class TitanConfig:
         self,
         path: Optional[Path],
         migration_manager: MigrationManager,
+        write_on_migration: bool = True,
     ) -> dict:
         """Load TOML and normalize it to the current config schema."""
         raw_config = self._load_toml(path)
@@ -148,14 +149,14 @@ class TitanConfig:
                 to_version=migration_result.final_version,
                 steps=migration_result.applied_steps,
             )
-            if path is not None:
+            if write_on_migration and path is not None:
                 self._write_toml(path, migration_result.data)
 
         return migration_result.data
 
     def _merge_configs(self, global_cfg: dict, project_cfg: dict) -> dict:
         """Merge global and project configs (project overrides global)"""
-        merged = {**global_cfg}
+        merged = deepcopy(global_cfg)
 
         # Project config overrides global
         for key, value in project_cfg.items():
@@ -175,12 +176,6 @@ class TitanConfig:
                         if pk != "config":
                             final_plugin_data[pk] = pv
 
-                    # Plugin source is a user-local concern. If global config already
-                    # defines a source override, preserve it instead of letting the
-                    # project config overwrite it.
-                    if "source" in plugin_data_global:
-                        final_plugin_data["source"] = plugin_data_global["source"]
-
                     # Handle the nested 'config' dictionary separately (deep merge)
                     config_section_global = plugin_data_global.get("config", {})
                     config_section_project = plugin_data_project.get("config", {})
@@ -253,6 +248,10 @@ class TitanConfig:
         """Get list of failed or misconfigured plugins."""
         return self._plugin_warnings
 
+    def get_plugin_sync_events(self) -> List[str]:
+        """Get list of plugin auto-sync events from the latest load cycle."""
+        return self._plugin_sync_events
+
     def get_project_name(self) -> Optional[str]:
         """Get the current project name from project config."""
         if self.config and self.config.project:
@@ -388,22 +387,75 @@ class TitanConfig:
         return plugin_cfg.enabled if plugin_cfg else False
 
     def get_plugin_source_channel(self, plugin_name: str) -> str:
-        """Return the configured source channel for a plugin."""
-        if not self.config or not self.config.plugins:
-            return "stable"
-        plugin_cfg = self.config.plugins.get(plugin_name)
-        if not plugin_cfg or not getattr(plugin_cfg, "source", None):
-            return "stable"
-        return plugin_cfg.source.channel or "stable"
+        """Return the effective source channel for a plugin."""
+        source = self.get_effective_plugin_source(plugin_name)
+        return source.get("channel", PluginChannel.STABLE)
 
     def get_plugin_source_path(self, plugin_name: str) -> Optional[Path]:
-        """Return the configured dev_local path for a plugin, if any."""
-        if not self.config or not self.config.plugins:
+        """Return the effective dev_local path for a plugin, if any."""
+        source = self.get_effective_plugin_source(plugin_name)
+        path = source.get("path")
+        if not path:
             return None
-        plugin_cfg = self.config.plugins.get(plugin_name)
-        if not plugin_cfg or not getattr(plugin_cfg, "source", None) or not plugin_cfg.source.path:
-            return None
-        return Path(plugin_cfg.source.path).expanduser().resolve()
+        return Path(path).expanduser().resolve()
+
+    def get_global_plugin_source(self, plugin_name: str) -> dict:
+        """Return the raw user-local source override for a plugin in the active project."""
+        scoped_source = self._get_project_source_scope_data().get("plugins", {}).get(plugin_name, {}).get("source", {})
+        if scoped_source:
+            return scoped_source.copy()
+
+        # Backward-compatible fallback for older global config layouts.
+        return (
+            self.global_config.get("plugins", {})
+            .get(plugin_name, {})
+            .get("source", {})
+            .copy()
+        )
+
+    def get_project_plugin_source(self, plugin_name: str) -> dict:
+        """Return the raw project source definition for a plugin."""
+        return (
+            self.project_config.get("plugins", {})
+            .get(plugin_name, {})
+            .get("source", {})
+            .copy()
+        )
+
+    def get_effective_plugin_source(self, plugin_name: str) -> dict:
+        """Return the effective plugin source after applying local overrides."""
+        global_source = self.get_global_plugin_source(plugin_name)
+        project_source = self.get_project_plugin_source(plugin_name)
+
+        if global_source.get("channel") == PluginChannel.DEV_LOCAL and global_source.get("path"):
+            return {
+                "channel": PluginChannel.DEV_LOCAL,
+                "path": global_source.get("path"),
+                "repo_url": project_source.get("repo_url"),
+                "requested_ref": project_source.get("requested_ref"),
+                "resolved_commit": project_source.get("resolved_commit"),
+            }
+
+        effective = dict(project_source)
+        effective.setdefault("channel", PluginChannel.STABLE)
+
+        # Preserve the remembered dev path for quick switching, but only as UX state.
+        if global_source.get("path") and "path" not in effective:
+            effective["path"] = global_source.get("path")
+
+        return effective
+
+    def get_project_plugin_repo_url(self, plugin_name: str) -> Optional[str]:
+        """Return the shared stable repository URL for a plugin."""
+        return self.get_project_plugin_source(plugin_name).get("repo_url")
+
+    def get_project_plugin_requested_ref(self, plugin_name: str) -> Optional[str]:
+        """Return the shared requested stable ref for a plugin."""
+        return self.get_project_plugin_source(plugin_name).get("requested_ref")
+
+    def get_project_plugin_resolved_commit(self, plugin_name: str) -> Optional[str]:
+        """Return the shared resolved stable commit for a plugin."""
+        return self.get_project_plugin_source(plugin_name).get("resolved_commit")
 
     def set_global_plugin_source(
         self,
@@ -413,7 +465,10 @@ class TitanConfig:
     ) -> None:
         """Persist a plugin source override in the global user config."""
         config_data = self._load_toml(self._global_config_path)
-        plugins_table = config_data.setdefault("plugins", {})
+        project_sources = config_data.setdefault("project_sources", {})
+        project_table = project_sources.setdefault(self._get_project_source_scope_key(), {})
+        project_table["project_path"] = str((self._project_root or Path.cwd()).resolve())
+        plugins_table = project_table.setdefault("plugins", {})
         plugin_table = plugins_table.setdefault(plugin_name, {})
         source_table = plugin_table.setdefault("source", {})
 
@@ -428,19 +483,74 @@ class TitanConfig:
     def clear_global_plugin_source(self, plugin_name: str) -> None:
         """Remove a plugin source override from the global user config."""
         config_data = self._load_toml(self._global_config_path)
-        plugins_table = config_data.get("plugins", {})
+        project_sources = config_data.get("project_sources", {})
+        project_key = self._find_project_source_scope_key(project_sources)
+        project_table = project_sources.get(project_key, {}) if project_key else {}
+        plugins_table = project_table.get("plugins", {})
         plugin_table = plugins_table.get(plugin_name)
         if not plugin_table:
+            # Fall back to cleaning any legacy global override for the plugin.
+            legacy_plugins = config_data.get("plugins", {})
+            legacy_plugin = legacy_plugins.get(plugin_name)
+            if not legacy_plugin:
+                return
+            legacy_plugin.pop("source", None)
+            if not legacy_plugin:
+                legacy_plugins.pop(plugin_name, None)
+            if not legacy_plugins and "plugins" in config_data:
+                config_data.pop("plugins", None)
+            self._write_global_config(config_data)
             return
 
         plugin_table.pop("source", None)
         if not plugin_table:
             plugins_table.pop(plugin_name, None)
-        if not plugins_table and "plugins" in config_data:
-            config_data.pop("plugins", None)
+        if not plugins_table and "plugins" in project_table:
+            project_table.pop("plugins", None)
+        if self._project_source_table_empty(project_table) and project_key in project_sources:
+            project_sources.pop(project_key, None)
+        if not project_sources and "project_sources" in config_data:
+            config_data.pop("project_sources", None)
 
         self._write_global_config(config_data)
 
+    def _get_project_source_scope_key(self) -> str:
+        """Return the global-config key used to scope local plugin overrides per project."""
+        project_path = str((self._project_root or Path.cwd()).resolve())
+        project_name = (self._project_root or Path.cwd()).resolve().name or "project"
+        safe_name = re.sub(r"[^a-zA-Z0-9]+", "_", project_name).strip("_").lower() or "project"
+        digest = hashlib.sha256(project_path.encode("utf-8")).hexdigest()[:8]
+        return f"p_{safe_name}_{digest}"
+
+    def _get_project_source_scope_data(self) -> dict:
+        """Return the scoped project source block for the active project."""
+        project_sources = self.global_config.get("project_sources", {})
+        project_key = self._find_project_source_scope_key(project_sources)
+        if project_key:
+            return project_sources.get(project_key, {})
+        return {}
+
+    def _find_project_source_scope_key(self, project_sources: dict) -> Optional[str]:
+        """Find the project_sources key matching the active project."""
+        current_path = str((self._project_root or Path.cwd()).resolve())
+        preferred_key = self._get_project_source_scope_key()
+        preferred_table = project_sources.get(preferred_key)
+        if isinstance(preferred_table, dict):
+            stored_path = preferred_table.get("project_path")
+            if not stored_path or stored_path == current_path:
+                return preferred_key
+
+        for key, value in project_sources.items():
+            if key == current_path:
+                return key
+            if isinstance(value, dict) and value.get("project_path") == current_path:
+                return key
+        return None
+
+    def _project_source_table_empty(self, project_table: dict) -> bool:
+        """Return whether a scoped project source block contains meaningful data."""
+        return not any(key != "project_path" for key in project_table)
+
     def get_status_bar_info(self) -> dict:
         """
         Get information for the status bar display.

{titan_cli-0.4.0 → titan_cli-0.4.2}/titan_cli/core/plugins/available.py

@@ -1,9 +1,4 @@
-"""
-This file contains a list of known, installable plugins for Titan CLI.
-
-This acts as a centralized registry for the `install` command, so the CLI
-knows what plugins are available to be installed via `pipx inject`.
-"""
+"""Registry of known official plugins available to Titan CLI."""
 from typing import TypedDict, List
 
 class KnownPlugin(TypedDict):