praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/features/__init__.py

@@ -0,0 +1,278 @@
+"""
+CLI Features Module for PraisonAI (agentic terminal product).
+
+This module contains modular CLI feature handlers that extend the base CLI
+functionality. Each feature is implemented as a separate module for
+maintainability and testability.
+
+Migrated to ``praisonai_code`` as part of the C0–C6 extraction (issue #2512).
+Public paths under ``praisonai.cli.features.*`` continue to work via a shim in
+the main ``praisonai`` package.
+
+Features:
+- guardrail: Output validation using LLM guardrails
+- metrics: Token usage and cost tracking
+- image: Image processing with ImageAgent
+- telemetry: Usage monitoring and analytics
+- mcp: Model Context Protocol server integration
+- fast_context: Codebase search capability
+- knowledge: RAG/vector store management
+- session: Session management for multi-turn conversations
+- tools: Tool registry management
+- handoff: Agent-to-agent delegation
+- auto_memory: Automatic memory extraction
+- todo: Todo list management
+- router: Smart model selection
+- flow_display: Visual workflow tracking
+- workflow: YAML workflow management
+- n8n: Export workflows to n8n visual editor
+- external_agents: External AI CLI tool integrations (Claude, Gemini, Codex, Cursor)
+- slash_commands: Interactive slash commands (/help, /cost, /plan, etc.)
+- autonomy_mode: Autonomy levels (suggest, auto-edit, full-auto)
+- cost_tracker: Real-time cost and token tracking
+- message_queue: Message queuing while agent is processing
+- at_mentions: @ mention autocomplete for files and directories
+- compare: CLI command comparison feature
+- eval: Agent evaluation framework (accuracy, performance, reliability, criteria)
+- hooks: Hook system for intercepting and modifying agent behavior
+- checkpoints: Shadow git checkpointing for file-level undo/restore
+- background: Background agent task execution and management
+- thinking: Thinking budget management
+- compaction: Context compaction settings
+- output_style: Output style configuration
+- ollama: Ollama provider and Weak-Model-Proof execution
+"""
+
+# Type hints available for IDE support
+
+# Lazy imports to avoid performance impact
+__all__ = [
+    'GuardrailHandler',
+    'MetricsHandler', 
+    'ImageHandler',
+    'TelemetryHandler',
+    'MCPHandler',
+    'FastContextHandler',
+    'KnowledgeHandler',
+    'SessionHandler',
+    'ToolsHandler',
+    'HandoffHandler',
+    'AutoMemoryHandler',
+    'TodoHandler',
+    'RouterHandler',
+    'FlowDisplayHandler',
+    'WorkflowHandler',
+    'N8nHandler',
+    'ExternalAgentsHandler',
+    # New CLI enhancement features
+    'SlashCommandHandler',
+    'AutonomyModeHandler',
+    'CostTrackerHandler',
+    'RepoMapHandler',
+    'InteractiveTUIHandler',
+    'GitIntegrationHandler',
+    'SandboxExecutorHandler',
+    'MessageQueueHandler',
+    # @ mention autocomplete
+    'AtMentionCompleter',
+    'CombinedCompleter',
+    'FileSearchService',
+    # Evaluation
+    'EvalHandler',
+    # Compare feature
+    'CompareHandler',
+    # Agent Skills
+    'SkillsHandler',
+    # Hooks
+    'HooksHandler',
+    # Checkpoints
+    'CheckpointsHandler',
+    # Background
+    'BackgroundHandler',
+    # Thinking, Compaction, Output Style
+    'ThinkingHandler',
+    'CompactionHandler',
+    'OutputStyleHandler',
+    # Ollama + WMP
+    'OllamaHandler',
+    # Capabilities (LiteLLM endpoint parity)
+    'CapabilitiesHandler',
+    # Performance benchmarking
+    'PerformanceHandler',
+    # Comprehensive benchmarking
+    'BenchmarkHandler',
+    # Lite agent (BYO-LLM)
+    'LiteHandler',
+    # Agent-centric tools (LSP/ACP powered)
+    'create_agent_centric_tools',
+    'InteractiveRuntime',
+    'RuntimeConfig',
+    'CodeIntelligenceRouter',
+    'ActionOrchestrator',
+    # Interactive tools provider (canonical source)
+    'get_interactive_tools',
+    'resolve_tool_groups',
+    'ToolConfig',
+    'TOOL_GROUPS',
+]
+
+def __getattr__(name):
+    """Lazy load handlers to minimize import overhead."""
+    if name == 'GuardrailHandler':
+        from .guardrail import GuardrailHandler
+        return GuardrailHandler
+    elif name == 'MetricsHandler':
+        from .metrics import MetricsHandler
+        return MetricsHandler
+    elif name == 'ImageHandler':
+        from .image import ImageHandler
+        return ImageHandler
+    elif name == 'TelemetryHandler':
+        from .telemetry import TelemetryHandler
+        return TelemetryHandler
+    elif name == 'MCPHandler':
+        from .mcp import MCPHandler
+        return MCPHandler
+    elif name == 'FastContextHandler':
+        from .fast_context import FastContextHandler
+        return FastContextHandler
+    elif name == 'KnowledgeHandler':
+        from .knowledge import KnowledgeHandler
+        return KnowledgeHandler
+    elif name == 'SessionHandler':
+        from .session import SessionHandler
+        return SessionHandler
+    elif name == 'ToolsHandler':
+        from .tools import ToolsHandler
+        return ToolsHandler
+    elif name == 'HandoffHandler':
+        from .handoff import HandoffHandler
+        return HandoffHandler
+    elif name == 'AutoMemoryHandler':
+        from .auto_memory import AutoMemoryHandler
+        return AutoMemoryHandler
+    elif name == 'TodoHandler':
+        from .todo import TodoHandler
+        return TodoHandler
+    elif name == 'RouterHandler':
+        from .router import RouterHandler
+        return RouterHandler
+    elif name == 'FlowDisplayHandler':
+        from .flow_display import FlowDisplayHandler
+        return FlowDisplayHandler
+    elif name == 'WorkflowHandler':
+        from .workflow import WorkflowHandler
+        return WorkflowHandler
+    elif name == 'N8nHandler':
+        from .n8n import N8nHandler
+        return N8nHandler
+    elif name == 'ExternalAgentsHandler':
+        from .external_agents import ExternalAgentsHandler
+        return ExternalAgentsHandler
+    # New CLI enhancement features
+    elif name == 'SlashCommandHandler':
+        from .slash_commands import SlashCommandHandler
+        return SlashCommandHandler
+    elif name == 'AutonomyModeHandler':
+        from .autonomy_mode import AutonomyModeHandler
+        return AutonomyModeHandler
+    elif name == 'CostTrackerHandler':
+        from .cost_tracker import CostTrackerHandler
+        return CostTrackerHandler
+    elif name == 'RepoMapHandler':
+        from .repo_map import RepoMapHandler
+        return RepoMapHandler
+    elif name == 'InteractiveTUIHandler':
+        from .interactive_tui import InteractiveTUIHandler
+        return InteractiveTUIHandler
+    elif name == 'GitIntegrationHandler':
+        from .git_integration import GitIntegrationHandler
+        return GitIntegrationHandler
+    elif name == 'SandboxExecutorHandler':
+        from .sandbox_executor import SandboxExecutorHandler
+        return SandboxExecutorHandler
+    elif name == 'MessageQueueHandler':
+        from .message_queue import MessageQueueHandler
+        return MessageQueueHandler
+    # @ mention autocomplete
+    elif name == 'AtMentionCompleter':
+        from .at_mentions import AtMentionCompleter
+        return AtMentionCompleter
+    elif name == 'CombinedCompleter':
+        from .at_mentions import CombinedCompleter
+        return CombinedCompleter
+    elif name == 'FileSearchService':
+        from .at_mentions import FileSearchService
+        return FileSearchService
+    elif name == 'CompareHandler':
+        from .compare import CompareHandler
+        return CompareHandler
+    elif name == 'EvalHandler':
+        from .eval import EvalHandler
+        return EvalHandler
+    elif name == 'SkillsHandler':
+        from .skills import SkillsHandler
+        return SkillsHandler
+    elif name == 'HooksHandler':
+        from .hooks import HooksHandler
+        return HooksHandler
+    elif name == 'CheckpointsHandler':
+        from .checkpoints import CheckpointsHandler
+        return CheckpointsHandler
+    elif name == 'BackgroundHandler':
+        from .background import BackgroundHandler
+        return BackgroundHandler
+    elif name == 'ThinkingHandler':
+        from .thinking import ThinkingHandler
+        return ThinkingHandler
+    elif name == 'CompactionHandler':
+        from .compaction import CompactionHandler
+        return CompactionHandler
+    elif name == 'OutputStyleHandler':
+        from .output_style import OutputStyleHandler
+        return OutputStyleHandler
+    elif name == 'OllamaHandler':
+        from .ollama import OllamaHandler
+        return OllamaHandler
+    elif name == 'CapabilitiesHandler':
+        from .capabilities import CapabilitiesHandler
+        return CapabilitiesHandler
+    elif name == 'PerformanceHandler':
+        from .performance import PerformanceHandler
+        return PerformanceHandler
+    elif name == 'BenchmarkHandler':
+        from .benchmark import BenchmarkHandler
+        return BenchmarkHandler
+    elif name == 'LiteHandler':
+        from .lite import LiteHandler
+        return LiteHandler
+    # Agent-centric tools (LSP/ACP powered)
+    elif name == 'create_agent_centric_tools':
+        from .agent_tools import create_agent_centric_tools
+        return create_agent_centric_tools
+    elif name == 'InteractiveRuntime':
+        from .interactive_runtime import InteractiveRuntime
+        return InteractiveRuntime
+    elif name == 'RuntimeConfig':
+        from .interactive_runtime import RuntimeConfig
+        return RuntimeConfig
+    elif name == 'CodeIntelligenceRouter':
+        from .code_intelligence import CodeIntelligenceRouter
+        return CodeIntelligenceRouter
+    elif name == 'ActionOrchestrator':
+        from .action_orchestrator import ActionOrchestrator
+        return ActionOrchestrator
+    # Interactive tools provider (canonical source)
+    elif name == 'get_interactive_tools':
+        from .interactive_tools import get_interactive_tools
+        return get_interactive_tools
+    elif name == 'resolve_tool_groups':
+        from .interactive_tools import resolve_tool_groups
+        return resolve_tool_groups
+    elif name == 'ToolConfig':
+        from .interactive_tools import ToolConfig
+        return ToolConfig
+    elif name == 'TOOL_GROUPS':
+        from .interactive_tools import TOOL_GROUPS
+        return TOOL_GROUPS
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

praisonai_code/cli/features/_endpoint_registry.py

@@ -0,0 +1,64 @@
+"""
+Registry for endpoint provider types.
+
+Maps endpoint types to their invocation methods (lazy-loaded).
+Extensible: third-party endpoint types can register via entry points.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Any
+
+from ..._registry import PluginRegistry
+
+
+# Built-in endpoint types - return callables that will be bound to the class instance
+def _recipe_loader():
+    def invoke_recipe(self, endpoint_name: str, input_data: Any, config: dict, parsed: dict):
+        return self._invoke_recipe(endpoint_name, input_data, config, parsed)
+    return invoke_recipe
+
+
+def _agents_api_loader():
+    def invoke_agents_api(self, endpoint_name: str, input_data: Any, config: dict, parsed: dict):
+        return self._invoke_agents_api(endpoint_name, input_data, config, parsed)
+    return invoke_agents_api
+
+
+def _mcp_loader():
+    def invoke_mcp(self, endpoint_name: str, input_data: Any, config: dict, parsed: dict):
+        return self._invoke_mcp(endpoint_name, input_data, config, parsed)
+    return invoke_mcp
+
+
+def _a2a_loader():
+    def invoke_a2a(self, endpoint_name: str, input_data: Any, config: dict, parsed: dict):
+        return self._invoke_a2a(endpoint_name, input_data, config, parsed)
+    return invoke_a2a
+
+
+def _a2u_loader():
+    def invoke_a2u(self, endpoint_name: str, input_data: Any, config: dict, parsed: dict):
+        return self._invoke_a2u(endpoint_name, input_data, config, parsed)
+    return invoke_a2u
+
+
+# Built-in endpoint types with lazy loading
+_BUILTIN_ENDPOINTS = {
+    "recipe": _recipe_loader,
+    "agents-api": _agents_api_loader,
+    "mcp": _mcp_loader,
+    "tools-mcp": _mcp_loader,  # Alias for mcp
+    "a2a": _a2a_loader,
+    "a2u": _a2u_loader,
+}
+
+
+class EndpointProviderRegistry(PluginRegistry):
+    """Registry for endpoint provider types."""
+    
+    def __init__(self):
+        super().__init__(
+            entry_point_group="praisonai.endpoints.providers",
+            builtins=_BUILTIN_ENDPOINTS
+        )

praisonai_code/cli/features/_search_registry.py

@@ -0,0 +1,43 @@
+"""
+Registry for web search providers.
+
+Maps search provider names to their tool classes (lazy-loaded).
+Extensible: third-party search providers can register via entry points.
+"""
+
+from __future__ import annotations
+
+from ..._registry import PluginRegistry
+
+
+def _duckduckgo_loader():
+    from praisonai_tools import DuckDuckGoTool
+    return DuckDuckGoTool
+
+
+def _tavily_loader():
+    from praisonai_tools import TavilyTool
+    return TavilyTool
+
+
+def _serper_loader():
+    from praisonai_tools import SerperTool
+    return SerperTool
+
+
+# Built-in search providers with lazy loading
+_BUILTIN_SEARCH = {
+    "duckduckgo": _duckduckgo_loader,
+    "tavily": _tavily_loader,
+    "serper": _serper_loader,
+}
+
+
+class SearchProviderRegistry(PluginRegistry):
+    """Registry for web search providers."""
+    
+    def __init__(self):
+        super().__init__(
+            entry_point_group="praisonai.tools.search",
+            builtins=_BUILTIN_SEARCH
+        )

praisonai_code/cli/features/acp.py

@@ -0,0 +1,236 @@
+"""
+ACP CLI handler for PraisonAI.
+
+Provides the `praisonai acp` command for IDE/editor integration.
+"""
+
+import argparse
+import logging
+import sys
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ACPHandler:
+    """Handler for ACP CLI commands."""
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser) -> None:
+        """Add ACP-specific arguments to parser."""
+        parser.add_argument(
+            "-w", "--workspace",
+            type=str,
+            default=".",
+            help="Workspace root directory (default: current directory)"
+        )
+        parser.add_argument(
+            "-a", "--agent",
+            type=str,
+            default="default",
+            help="Agent name or configuration file"
+        )
+        parser.add_argument(
+            "--agents",
+            type=str,
+            help="Multi-agent configuration YAML file"
+        )
+        parser.add_argument(
+            "--router",
+            action="store_true",
+            help="Enable router agent for task delegation"
+        )
+        parser.add_argument(
+            "-m", "--model",
+            type=str,
+            help="LLM model to use"
+        )
+        parser.add_argument(
+            "-r", "--resume",
+            type=str,
+            nargs="?",
+            const="__last__",
+            help="Resume session by ID (or --resume --last for most recent)"
+        )
+        parser.add_argument(
+            "--last",
+            action="store_true",
+            help="Resume the last session (use with --resume)"
+        )
+        parser.add_argument(
+            "--approve",
+            type=str,
+            choices=["manual", "auto", "scoped"],
+            default="manual",
+            help="Approval mode for actions (default: manual)"
+        )
+        parser.add_argument(
+            "--read-only",
+            action="store_true",
+            default=True,
+            help="Read-only mode (default: enabled)"
+        )
+        parser.add_argument(
+            "--allow-write",
+            action="store_true",
+            help="Allow file write operations"
+        )
+        parser.add_argument(
+            "--allow-shell",
+            action="store_true",
+            help="Allow shell command execution"
+        )
+        parser.add_argument(
+            "--allow-network",
+            action="store_true",
+            help="Allow network requests"
+        )
+        parser.add_argument(
+            "--debug",
+            action="store_true",
+            help="Enable debug logging to stderr"
+        )
+        parser.add_argument(
+            "--profile",
+            type=str,
+            help="Use named profile from config"
+        )
+    
+    @staticmethod
+    def handle(args: argparse.Namespace) -> int:
+        """
+        Handle ACP command execution.
+        
+        Returns:
+            Exit code (0 for success, non-zero for error)
+        """
+        # Check if ACP SDK is available
+        try:
+            import importlib.util
+            if importlib.util.find_spec("acp") is None:
+                print(
+                    "Error: agent-client-protocol package not installed.\n"
+                    "Install with: pip install praisonai[acp]\n"
+                    "Or: pip install agent-client-protocol",
+                    file=sys.stderr
+                )
+                return 1
+        except Exception as e:
+            print(f"Error checking ACP availability: {e}", file=sys.stderr)
+            return 1
+        
+        # Import ACP module
+        try:
+            from praisonai.acp import serve
+        except ImportError as e:
+            print(f"Error importing ACP module: {e}", file=sys.stderr)
+            return 1
+        
+        # Determine resume session
+        resume_session: Optional[str] = None
+        resume_last = False
+        
+        if args.resume:
+            if args.resume == "__last__" or args.last:
+                resume_last = True
+            else:
+                resume_session = args.resume
+        elif args.last:
+            resume_last = True
+        
+        # Determine read-only mode
+        read_only = args.read_only and not args.allow_write
+        
+        try:
+            # Start ACP server
+            serve(
+                workspace=args.workspace,
+                agent=args.agent,
+                model=args.model,
+                resume=resume_session,
+                resume_last=resume_last,
+                debug=args.debug,
+                read_only=read_only,
+                allow_write=args.allow_write,
+                allow_shell=args.allow_shell,
+                approval_mode=args.approve,
+            )
+            return 0
+        except KeyboardInterrupt:
+            logger.info("ACP server stopped by user")
+            return 0
+        except Exception as e:
+            logger.exception(f"ACP server error: {e}")
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+
+
+def setup_acp_subparser(subparsers) -> None:
+    """Set up the ACP subcommand parser."""
+    acp_parser = subparsers.add_parser(
+        "acp",
+        help="Start ACP server for IDE/editor integration",
+        description=(
+            "Start the Agent Client Protocol (ACP) server.\n\n"
+            "This allows IDEs and editors (Zed, JetBrains, VSCode, Toad) "
+            "to connect to PraisonAI agents via JSON-RPC over stdio."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  praisonai acp                    # Start with defaults
+  praisonai acp --debug            # Enable debug logging
+  praisonai acp --resume --last    # Resume last session
+  praisonai acp --allow-write      # Enable file writes
+  praisonai acp -m gpt-4o          # Use specific model
+
+Editor Configuration:
+
+  Zed (~/.config/zed/settings.json):
+    {
+      "agent_servers": {
+        "PraisonAI": {
+          "command": "praisonai",
+          "args": ["acp"],
+          "env": {}
+        }
+      }
+    }
+
+  JetBrains (~/.jetbrains/acp.json):
+    {
+      "agent_servers": {
+        "PraisonAI": {
+          "command": "praisonai",
+          "args": ["acp"],
+          "env": {}
+        }
+      }
+    }
+
+  Toad:
+    toad acp "praisonai acp"
+"""
+    )
+    ACPHandler.add_arguments(acp_parser)
+    acp_parser.set_defaults(func=lambda args: ACPHandler.handle(args))
+
+
+def run_acp_command(args: Optional[list] = None) -> int:
+    """
+    Run ACP command directly.
+    
+    This can be called from the main CLI or as a standalone entry point.
+    """
+    parser = argparse.ArgumentParser(
+        prog="praisonai acp",
+        description="Start ACP server for IDE/editor integration"
+    )
+    ACPHandler.add_arguments(parser)
+    
+    parsed_args = parser.parse_args(args)
+    return ACPHandler.handle(parsed_args)
+
+
+if __name__ == "__main__":
+    sys.exit(run_acp_command())