praisonai-code 0.0.4__tar.gz → 0.0.5__tar.gz

{praisonai_code-0.0.4 → praisonai_code-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonai-code
-Version: 0.0.4
+Version: 0.0.5
 Summary: Agentic terminal CLI for PraisonAI — the terminal-native agent (run, chat, code, runtime, cli backends) extracted from the praisonai wrapper.
 Author: Mervin Praison
 License: MIT
@@ -42,9 +42,14 @@ Agentic terminal CLI for PraisonAI — the terminal-native agent product
 | C4 | Agentic features | Done |
 | C5 | `main.py`, `app.py`, config/session/utils + shims | Done |
 | C6 | Integration gate + sign-off | Done |
+| C7 | Hot-path standalone (agentic CLI without wrapper import) | Done |
 
 - `praisonai_code.runtime` — warm local runtime (daemon + thin client).
 - `praisonai_code.cli_backends` — CLI backend implementations (e.g. Claude Code).
+- `praisonai_code.llm` — endpoint resolution, credentials, model catalogue.
+- `praisonai_code.tool_resolver` — YAML tool name resolution.
+
+See `src/praisonai/tests/C7_VERIFICATION.md` for the hot-path sign-off checklist.
 
 ## Dependency rules
 
@@ -57,11 +62,21 @@ praisonai-code    →  depends on  praisonaiagents (core SDK)
 click, textual, PyYAML, python-dotenv, litellm, mcp, pydantic — see
 `pyproject.toml`). The rules above govern the **inter-package** direction.
 
-> **C7 note:** Some modules still import the `praisonai` wrapper at runtime
-> (~170 files). **Standalone `pip install praisonai-code` without `praisonai`
-> is not fully supported yet.** Use `pip install praisonai` for production.
-> Residual C1 back-imports: `runtime/descriptor.py` → `praisonai.version`;
-> `cli_backends/registry.py` → `praisonai._registry`.
+> **C7 (hot path complete):** Standalone `pip install praisonai-code` supports
+> agentic terminal commands (`run`, `chat`, `code`, warm runtime) without importing
+> the wrapper on the hot path. Approval backends resolve locally via
+> `praisonai_code.cli.features._approval_bridge` (channel bots delegate to the
+> wrapper). Optional features (observability sinks, framework adapters,
+> bots/gateway) remain wrapper-only via `praisonai_code._wrapper_bridge`.
+
+Completed C7 steps:
+- `praisonai_code._registry` — vendored plugin registry (no wrapper import)
+- `praisonai_code._version` / `runtime/descriptor.py` — version from `praisonai-code`
+- `praisonai_code.__main__` + `praisonai-code` console script — standalone entry
+- `praisonai_code._logging` — CLI logging without wrapper dependency
+- `praisonai_code.llm.*` — env, credentials, catalogue, config
+- `praisonai_code._framework_availability`, `_safe_loader`, `tool_resolver` — execution helpers
+- Namespace cleanup — `praisonai_code.cli.features.*` local imports on agentic path
 
 Backward compatibility is preserved via PEP 562 shims at the old
 `praisonai.*` import paths, so `pip install praisonai` and
@@ -75,6 +90,14 @@ Backward compatibility is preserved via PEP 562 shims at the old
 pip install praisonai
 ```
 
+**Standalone code package (agentic CLI only):**
+
+```bash
+pip install praisonai-code
+praisonai-code --version
+python -m praisonai_code --help
+```
+
 **Development / monorepo:**
 
 ```bash

{praisonai_code-0.0.4 → praisonai_code-0.0.5}/README.md

@@ -20,9 +20,14 @@ Agentic terminal CLI for PraisonAI — the terminal-native agent product
 | C4 | Agentic features | Done |
 | C5 | `main.py`, `app.py`, config/session/utils + shims | Done |
 | C6 | Integration gate + sign-off | Done |
+| C7 | Hot-path standalone (agentic CLI without wrapper import) | Done |
 
 - `praisonai_code.runtime` — warm local runtime (daemon + thin client).
 - `praisonai_code.cli_backends` — CLI backend implementations (e.g. Claude Code).
+- `praisonai_code.llm` — endpoint resolution, credentials, model catalogue.
+- `praisonai_code.tool_resolver` — YAML tool name resolution.
+
+See `src/praisonai/tests/C7_VERIFICATION.md` for the hot-path sign-off checklist.
 
 ## Dependency rules
 
@@ -35,11 +40,21 @@ praisonai-code    →  depends on  praisonaiagents (core SDK)
 click, textual, PyYAML, python-dotenv, litellm, mcp, pydantic — see
 `pyproject.toml`). The rules above govern the **inter-package** direction.
 
-> **C7 note:** Some modules still import the `praisonai` wrapper at runtime
-> (~170 files). **Standalone `pip install praisonai-code` without `praisonai`
-> is not fully supported yet.** Use `pip install praisonai` for production.
-> Residual C1 back-imports: `runtime/descriptor.py` → `praisonai.version`;
-> `cli_backends/registry.py` → `praisonai._registry`.
+> **C7 (hot path complete):** Standalone `pip install praisonai-code` supports
+> agentic terminal commands (`run`, `chat`, `code`, warm runtime) without importing
+> the wrapper on the hot path. Approval backends resolve locally via
+> `praisonai_code.cli.features._approval_bridge` (channel bots delegate to the
+> wrapper). Optional features (observability sinks, framework adapters,
+> bots/gateway) remain wrapper-only via `praisonai_code._wrapper_bridge`.
+
+Completed C7 steps:
+- `praisonai_code._registry` — vendored plugin registry (no wrapper import)
+- `praisonai_code._version` / `runtime/descriptor.py` — version from `praisonai-code`
+- `praisonai_code.__main__` + `praisonai-code` console script — standalone entry
+- `praisonai_code._logging` — CLI logging without wrapper dependency
+- `praisonai_code.llm.*` — env, credentials, catalogue, config
+- `praisonai_code._framework_availability`, `_safe_loader`, `tool_resolver` — execution helpers
+- Namespace cleanup — `praisonai_code.cli.features.*` local imports on agentic path
 
 Backward compatibility is preserved via PEP 562 shims at the old
 `praisonai.*` import paths, so `pip install praisonai` and
@@ -53,6 +68,14 @@ Backward compatibility is preserved via PEP 562 shims at the old
 pip install praisonai
 ```
 
+**Standalone code package (agentic CLI only):**
+
+```bash
+pip install praisonai-code
+praisonai-code --version
+python -m praisonai_code --help
+```
+
 **Development / monorepo:**
 
 ```bash

{praisonai_code-0.0.4 → praisonai_code-0.0.5}/praisonai_code/__init__.py

@@ -12,6 +12,6 @@ the remaining terminal-agent modules, with PEP 562 shims left behind at the
 old ``praisonai.*`` paths for backward compatibility.
 """
 
-__version__ = "0.0.2"
+__version__ = "0.0.4"
 
 __all__ = ["__version__"]

praisonai_code-0.0.5/praisonai_code/__main__.py

@@ -0,0 +1,19 @@
+"""Console entry for ``python -m praisonai_code`` and ``praisonai-code`` script."""
+
+from __future__ import annotations
+
+import os
+
+
+def main() -> None:
+    """Run the Typer CLI (agentic terminal product)."""
+    from praisonai_code._logging import configure_cli_logging
+    from praisonai_code.cli.app import app, register_commands
+
+    configure_cli_logging(os.environ.get("LOGLEVEL", "WARNING") or "WARNING")
+    register_commands()
+    app()
+
+
+if __name__ == "__main__":
+    main()

praisonai_code-0.0.5/praisonai_code/_framework_availability.py

@@ -0,0 +1,134 @@
+"""Single source of truth for optional-framework availability."""
+import importlib.util
+import importlib.metadata
+import threading
+from typing import Callable
+
+_cache: dict[str, bool] = {}
+_lock = threading.Lock()
+
+def _ag2_probe() -> bool:
+    # AG2 ships under the `autogen` namespace; presence of the dist is
+    # the only reliable signal.
+    try:
+        importlib.metadata.distribution('ag2')
+    except importlib.metadata.PackageNotFoundError:
+        return False
+    return importlib.util.find_spec("autogen") is not None
+
+def _autogen_v4_probe() -> bool:
+    return (importlib.util.find_spec("autogen_agentchat") is not None
+            and importlib.util.find_spec("autogen_ext") is not None)
+
+def _langgraph_probe() -> bool:
+    # find_spec on a submodule imports the parent package; guard against
+    # import-time errors in langgraph/its deps crashing the availability check.
+    try:
+        if importlib.util.find_spec("langgraph") is None:
+            return False
+        return importlib.util.find_spec("langgraph.prebuilt") is not None
+    except Exception:
+        return False
+
+def _openai_agents_probe() -> bool:
+    try:
+        importlib.metadata.distribution("openai-agents")
+    except importlib.metadata.PackageNotFoundError:
+        return False
+    if importlib.util.find_spec("agents") is None:
+        return False
+    try:
+        from agents import Runner  # noqa: F401
+        return True
+    except Exception:
+        return False
+
+def _agno_probe() -> bool:
+    try:
+        importlib.metadata.distribution("agno")
+    except importlib.metadata.PackageNotFoundError:
+        return False
+    if importlib.util.find_spec("agno") is None:
+        return False
+    try:
+        from agno.agent import Agent  # noqa: F401
+        return True
+    except Exception:
+        return False
+
+def _google_adk_probe() -> bool:
+    try:
+        importlib.metadata.distribution("google-adk")
+    except importlib.metadata.PackageNotFoundError:
+        return False
+    if importlib.util.find_spec("google.adk") is None:
+        return False
+    try:
+        from google.adk.agents import Agent  # noqa: F401
+        return True
+    except Exception:
+        try:
+            from google.adk import Agent  # noqa: F401
+            return True
+        except Exception:
+            return False
+
+def _pydantic_ai_probe() -> bool:
+    try:
+        importlib.metadata.distribution("pydantic-ai")
+    except importlib.metadata.PackageNotFoundError:
+        return False
+    if importlib.util.find_spec("pydantic_ai") is None:
+        return False
+    try:
+        from pydantic_ai import Agent  # noqa: F401
+        return True
+    except Exception:
+        return False
+
+_PROBES: dict[str, Callable[[], bool]] = {
+    "crewai":            lambda: importlib.util.find_spec("crewai") is not None,
+    "autogen":           lambda: importlib.util.find_spec("autogen") is not None,
+    "autogen_v4":        _autogen_v4_probe,
+    "ag2":               _ag2_probe,
+    "praisonaiagents":   lambda: importlib.util.find_spec("praisonaiagents") is not None,
+    "praisonai_tools":   lambda: importlib.util.find_spec("praisonai_tools") is not None,
+    "agentops":          lambda: importlib.util.find_spec("agentops") is not None,
+    "litellm":           lambda: importlib.util.find_spec("litellm") is not None,
+    "openai":            lambda: importlib.util.find_spec("openai") is not None,
+    # Additional probes for Gap 2 consolidation
+    "acp":               lambda: importlib.util.find_spec("acp") is not None,
+    "rich":              lambda: importlib.util.find_spec("rich") is not None,
+    "gradio":            lambda: importlib.util.find_spec("gradio") is not None,
+    "unsloth":           lambda: importlib.util.find_spec("unsloth") is not None,
+    # Vector store probes for Gap 3 fix
+    "chromadb":          lambda: importlib.util.find_spec("chromadb") is not None,
+    "pinecone":          lambda: importlib.util.find_spec("pinecone") is not None,
+    "qdrant_client":     lambda: importlib.util.find_spec("qdrant_client") is not None,
+    "weaviate":          lambda: importlib.util.find_spec("weaviate") is not None,
+    "langgraph":         _langgraph_probe,
+    "openai_agents":     _openai_agents_probe,
+    "agno":              _agno_probe,
+    "google_adk":        _google_adk_probe,
+    "pydantic_ai":       _pydantic_ai_probe,
+}
+
+def is_available(name: str) -> bool:
+    if name not in _PROBES:
+        raise ValueError(f"unknown framework name: {name!r}")
+    cached = _cache.get(name)
+    if cached is not None:
+        return cached
+    with _lock:
+        cached = _cache.get(name)
+        if cached is None:
+            cached = bool(_PROBES[name]())
+            _cache[name] = cached
+        return cached
+
+def invalidate(name: str | None = None) -> None:
+    with _lock:
+        if name is None:
+            _cache.clear()
+        else:
+            _cache.pop(name, None)

praisonai_code-0.0.5/praisonai_code/_logging.py

@@ -0,0 +1,24 @@
+"""Logging helpers for praisonai-code (no praisonai wrapper dependency)."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+_PKG_LOGGER = "praisonai_code"
+_configured = False
+
+
+def configure_cli_logging(level: str | int | None = None) -> None:
+    """Configure root logging once from the CLI entrypoint."""
+    global _configured
+    if _configured:
+        return
+    lvl = level or os.environ.get("LOGLEVEL", "WARNING")
+    logging.basicConfig(level=lvl, format="%(asctime)s - %(levelname)s - %(message)s")
+    _configured = True
+
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    """Return a namespaced logger under ``praisonai_code``."""
+    return logging.getLogger(f"{_PKG_LOGGER}.{name}" if name else _PKG_LOGGER)

praisonai_code-0.0.5/praisonai_code/_registry.py

@@ -0,0 +1,343 @@
+"""Generic plugin registry implementation for PraisonAI.
+
+This module provides a unified registry pattern to replace the divergent singleton
+implementations across the codebase. It supports both built-in and entry-point
+based plugin discovery with thread-safe registration and dependency injection.
+"""
+
+from __future__ import annotations
+
+import threading
+from importlib.metadata import entry_points
+from typing import Callable, Dict, Generic, Optional, Type, TypeVar
+import logging
+
+T = TypeVar("T")
+logger = logging.getLogger(__name__)
+
+
+class PluginRegistry(Generic[T]):
+    # Guards creation of per-subclass default-instance locks
+    _default_locks_guard = threading.Lock()
+    """Generic plugin registry: builtins + entry points + runtime register().
+    
+    This replaces the singleton pattern with dependency injection while maintaining
+    the same functionality. Supports:
+    - Built-in plugins with lazy loading
+    - Entry points discovery
+    - Runtime registration
+    - Alias support for alternative names
+    - Thread-safe operations
+    """
+
+    def __init__(
+        self, 
+        *,
+        entry_point_group: str,
+        builtins: Optional[Dict[str, Callable[[], Type[T]]]] = None,
+        discover_entry_points: bool = True
+    ) -> None:
+        """Initialize the registry.
+        
+        Args:
+            entry_point_group: Entry points group name for plugin discovery
+            builtins: Dict of name -> loader function for built-in plugins
+            discover_entry_points: When True (default) the registry scans the
+                ``entry_point_group`` for third-party plugins on construction.
+                Pass False to build an isolated registry that only contains the
+                supplied builtins / explicitly registered plugins (useful for
+                opt-out and deterministic tests).
+        """
+        self._entry_point_group = entry_point_group
+        self._loaders: Dict[str, Callable[[], Type[T]]] = {}  # lazy loaders
+        self._items: Dict[str, Type[T]] = {}  # resolved cache
+        self._aliases: Dict[str, str] = {}  # alias -> canonical name
+        self._lock = threading.RLock()  # Use RLock for re-entrant access
+        
+        # Store built-in loaders (normalized) without calling them
+        if builtins:
+            for name, loader in builtins.items():
+                self._add_loader(name, loader)
+        
+        if discover_entry_points:
+            self._discover_entry_points()
+
+    def _add_loader(self, name: str, loader: Callable[[], Type[T]]) -> None:
+        """Add a loader with normalized name."""
+        normalized_name = name.lower()
+        self._loaders[normalized_name] = loader
+
+    def _discover_entry_points(self) -> None:
+        """Discover entry point loaders without loading them."""
+        try:
+            for ep in entry_points(group=self._entry_point_group):
+                self._add_loader(ep.name, ep.load)
+        except Exception:
+            # entry_points() might not be available in older Python versions
+            logger.debug("Entry points not available for group %s", self._entry_point_group)
+
+    def register(
+        self, 
+        name: str, 
+        cls: Type[T], 
+        *, 
+        aliases: Optional[list[str]] = None
+    ) -> None:
+        """Register a plugin at runtime.
+        
+        Args:
+            name: Plugin name
+            cls: Plugin class
+            aliases: Optional list of alias names for this plugin
+        """
+        with self._lock:
+            canonical_name = name.lower()
+            # Store both in loaders (for consistency with discovery) and items (for immediate access)
+            self._loaders[canonical_name] = lambda: cls
+            self._items[canonical_name] = cls
+            
+            # Register aliases
+            if aliases:
+                for alias in aliases:
+                    normalized_alias = alias.lower()
+                    self._aliases[normalized_alias] = canonical_name
+
+    def unregister(self, name: str) -> bool:
+        """Unregister a plugin.
+        
+        Args:
+            name: Plugin name
+            
+        Returns:
+            True if plugin was found and removed, False otherwise
+        """
+        with self._lock:
+            normalized_name = name.lower()
+            
+            # Check if it's an alias
+            if normalized_name in self._aliases:
+                del self._aliases[normalized_name]
+                return True
+            
+            # Check if it's a canonical name
+            if normalized_name in self._loaders:
+                # Remove all aliases pointing to this plugin
+                aliases_to_remove = [
+                    alias for alias, canonical in self._aliases.items()
+                    if canonical == normalized_name
+                ]
+                for alias in aliases_to_remove:
+                    del self._aliases[alias]
+                
+                # Remove from both loaders and items cache
+                del self._loaders[normalized_name]
+                self._items.pop(normalized_name, None)
+                return True
+            
+            return False
+
+    def resolve(self, name: str) -> Type[T]:
+        """Resolve a plugin name to its class.
+        
+        Args:
+            name: Plugin name
+            
+        Returns:
+            Plugin class
+            
+        Raises:
+            ValueError: If plugin is not found
+        """
+        normalized_name = name.lower()
+        
+        with self._lock:
+            # Check cache first
+            canonical_name = self._aliases.get(normalized_name, normalized_name)
+            cls = self._items.get(canonical_name)
+            
+            if cls is not None:
+                return cls
+            
+            # Try to load from loaders
+            loader = self._loaders.get(canonical_name)
+            if loader is None:
+                # Capture available plugins snapshot while holding lock
+                available_loaders = sorted(self._loaders.keys())
+                available_aliases = sorted(self._aliases.keys())
+                available_snapshot = available_loaders + available_aliases
+                raise ValueError(
+                    f"Unknown {self._entry_point_group} plugin: {name!r}. "
+                    f"Available: {available_snapshot}"
+                )
+            
+            # Load and cache the plugin (release lock during loading to prevent deadlock)
+            pass
+        
+        # Load outside the lock to prevent deadlock if loader calls back into registry
+        try:
+            cls = loader()
+        except ImportError as e:
+            raise ValueError(
+                f"Plugin {name!r} is registered but its dependencies "
+                f"are not installed: {e}"
+            ) from e
+        
+        # Re-acquire lock to cache the result. Guard against the loader being
+        # replaced or removed by another thread while we loaded outside the
+        # lock, so we never resurrect an unregistered plugin or cache a stale
+        # class over a newer registration.
+        with self._lock:
+            if self._loaders.get(canonical_name) is loader:
+                self._items[canonical_name] = cls
+            return cls
+
+    def create(self, name: str, *args, **kwargs) -> T:
+        """Create an instance of the specified plugin.
+        
+        Args:
+            name: Plugin name
+            *args, **kwargs: Arguments to pass to plugin constructor
+            
+        Returns:
+            Plugin instance
+            
+        Raises:
+            ValueError: If plugin is not found
+        """
+        cls = self.resolve(name)
+        return cls(*args, **kwargs)
+
+    def list_names(self) -> list[str]:
+        """List all registered plugin names.
+        
+        Returns:
+            Sorted list of plugin names
+        """
+        with self._lock:
+            return sorted(self._loaders.keys())
+
+    def is_available(self, name: str) -> bool:
+        """Check if a plugin is available.
+        
+        Args:
+            name: Plugin name
+            
+        Returns:
+            True if plugin exists and can be created
+        """
+        try:
+            self.resolve(name)
+            return True
+        except ValueError:
+            return False
+
+    def list_aliases(self) -> Dict[str, str]:
+        """List all aliases and their target plugins.
+        
+        Returns:
+            Dict mapping alias -> canonical name
+        """
+        with self._lock:
+            return dict(self._aliases)
+
+    def list_all_names(self) -> list[str]:
+        """List all names including aliases.
+        
+        Returns:
+            Sorted list of all registered names and aliases
+        """
+        with self._lock:
+            return sorted(list(self._loaders.keys()) + list(self._aliases.keys()))
+    
+    def get_by_attr(self, module_name: str, attr_name: str) -> Type[T]:
+        """Get a plugin by attribute name for __getattr__ dispatch.
+        
+        Args:
+            module_name: Module name requesting the attribute (for error messages)
+            attr_name: Attribute name to resolve
+            
+        Returns:
+            Plugin class
+            
+        Raises:
+            AttributeError: If plugin is not found
+        """
+        try:
+            return self.resolve(attr_name)
+        except ValueError:
+            raise AttributeError(f"module {module_name!r} has no attribute {attr_name!r}")
+
+    @classmethod
+    def default(cls) -> "PluginRegistry[T]":
+        """
+        Process-default registry. Prefer DI; use this only at the edge.
+        
+        Provides thread-safe lazy initialization of default instances per-subclass.
+        Each subclass gets its own default instance cache.
+        """
+        # Use a class-level cache stored in the subclass's __dict__
+        cache_key = "_default_instance"
+        lock_key = "_default_instance_lock"
+        
+        # Get or create lock in subclass __dict__ (not shared across inheritance hierarchy)
+        if lock_key not in cls.__dict__:
+            # Thread-safe initialization of the per-subclass lock itself
+            with PluginRegistry._default_locks_guard:
+                if lock_key not in cls.__dict__:
+                    # Store directly in the class __dict__ to avoid inheritance sharing
+                    setattr(cls, lock_key, threading.Lock())
+        
+        lock = getattr(cls, lock_key)
+        
+        # Check cache first (without lock for performance)
+        cache = cls.__dict__.get(cache_key)
+        if cache is not None:
+            return cache
+        
+        # Double-checked locking pattern
+        with lock:
+            cache = cls.__dict__.get(cache_key)
+            if cache is None:
+                cache = cls()
+                # Store directly in the class __dict__ to ensure per-subclass isolation
+                setattr(cls, cache_key, cache)
+            return cache
+
+
+def create_lazy_getattr(registry: PluginRegistry[T]) -> Callable[[str], T]:
+    """Create a __getattr__ function backed by a PluginRegistry.
+    
+    This replaces manual if/elif ladders in __init__.py files with a data-driven
+    approach using the plugin registry.
+    
+    Args:
+        registry: The plugin registry to use for resolution
+        
+    Returns:
+        Function that can be used as __getattr__ in a module
+        
+    Example:
+        # In __init__.py:
+        from ._registry import create_lazy_getattr
+        
+        # Assuming you have a registry instance
+        __getattr__ = create_lazy_getattr(my_registry)
+    """
+    # Capture the *defining* module's name once, so the AttributeError reports
+    # the module that actually lacks the attribute rather than the caller, and
+    # we avoid inspecting the call stack on every failed lookup.
+    import inspect
+
+    frame = inspect.currentframe()
+    if frame and frame.f_back:
+        module_name = frame.f_back.f_globals.get('__name__', 'unknown')
+    else:
+        module_name = 'unknown'
+
+    def __getattr__(name: str) -> T:
+        try:
+            return registry.resolve(name)
+        except ValueError:
+            raise AttributeError(f"module {module_name!r} has no attribute {name!r}")
+
+    return __getattr__