nc1709 1.15.4__py3-none-any.whl

nc1709/agent/mcp_bridge.py

@@ -0,0 +1,245 @@
+"""
+MCP Bridge
+
+Integrates MCP (Model Context Protocol) servers into the agent's tool registry.
+Allows the agent to use tools from external MCP servers.
+"""
+
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from .tools.base import Tool, ToolResult, ToolParameter, ToolPermission, ToolRegistry
+
+
+class MCPTool(Tool):
+    """
+    A tool that wraps an MCP server tool.
+
+    Allows MCP tools to be used seamlessly alongside built-in tools.
+    """
+
+    category = "mcp"
+    permission = ToolPermission.ASK  # Ask before using MCP tools
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        parameters: List[ToolParameter],
+        mcp_manager,
+        server_name: str,
+    ):
+        """Initialize MCP tool wrapper
+
+        Args:
+            name: Tool name
+            description: Tool description
+            parameters: Tool parameters
+            mcp_manager: MCP manager for executing calls
+            server_name: Name of the MCP server providing this tool
+        """
+        super().__init__()
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self._mcp_manager = mcp_manager
+        self._server_name = server_name
+
+    def execute(self, **kwargs) -> ToolResult:
+        """Execute the MCP tool"""
+        try:
+            # Run async MCP call synchronously
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                result = loop.run_until_complete(
+                    self._mcp_manager.call_tool(self.name, kwargs)
+                )
+            finally:
+                loop.close()
+
+            # Parse MCP result
+            if "error" in result:
+                return ToolResult(
+                    success=False,
+                    output="",
+                    error=result["error"],
+                    target=str(kwargs)[:30],
+                )
+
+            # Extract content
+            output = ""
+            if "content" in result:
+                for item in result["content"]:
+                    if item.get("type") == "text":
+                        output += item.get("text", "")
+
+            return ToolResult(
+                success=True,
+                output=output or str(result),
+                target=str(kwargs)[:30],
+                data=result,
+            )
+
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"MCP tool error: {e}",
+                target=str(kwargs)[:30],
+            )
+
+
+class MCPBridge:
+    """
+    Bridge between MCP servers and the agent tool registry.
+
+    Discovers tools from MCP servers and registers them as agent tools.
+    """
+
+    def __init__(self, registry: ToolRegistry = None):
+        """Initialize the MCP bridge
+
+        Args:
+            registry: Tool registry to add MCP tools to
+        """
+        self.registry = registry or ToolRegistry()
+        self._mcp_manager = None
+        self._registered_tools: Dict[str, MCPTool] = {}
+
+    def connect_mcp_manager(self, mcp_manager) -> None:
+        """Connect to an MCP manager
+
+        Args:
+            mcp_manager: MCPManager instance
+        """
+        self._mcp_manager = mcp_manager
+
+    def discover_and_register_tools(self) -> int:
+        """Discover tools from MCP servers and register them
+
+        Returns:
+            Number of tools registered
+        """
+        if not self._mcp_manager:
+            return 0
+
+        count = 0
+
+        try:
+            # Get all tools from MCP manager
+            all_tools = self._mcp_manager.get_all_tools()
+
+            # Register local tools
+            for tool in all_tools.get("local", []):
+                mcp_tool = self._create_mcp_tool(tool, "local")
+                if mcp_tool:
+                    self.registry.register(mcp_tool)
+                    self._registered_tools[mcp_tool.name] = mcp_tool
+                    count += 1
+
+            # Register remote tools
+            for tool in all_tools.get("remote", []):
+                mcp_tool = self._create_mcp_tool(tool, "remote")
+                if mcp_tool:
+                    self.registry.register(mcp_tool)
+                    self._registered_tools[mcp_tool.name] = mcp_tool
+                    count += 1
+
+        except Exception as e:
+            print(f"Error discovering MCP tools: {e}")
+
+        return count
+
+    def _create_mcp_tool(self, mcp_tool_def, server_name: str) -> Optional[MCPTool]:
+        """Create an MCPTool from an MCP tool definition
+
+        Args:
+            mcp_tool_def: MCP tool definition object
+            server_name: Name of providing server
+
+        Returns:
+            MCPTool instance or None
+        """
+        try:
+            # Extract tool info
+            name = mcp_tool_def.name
+            description = mcp_tool_def.description or f"MCP tool: {name}"
+
+            # Convert parameters
+            parameters = []
+            if hasattr(mcp_tool_def, 'parameters') and mcp_tool_def.parameters:
+                for param in mcp_tool_def.parameters:
+                    parameters.append(ToolParameter(
+                        name=param.name,
+                        description=param.description or param.name,
+                        type=self._map_type(param.type) if hasattr(param, 'type') else "string",
+                        required=getattr(param, 'required', True),
+                    ))
+
+            # Prefix MCP tool names to avoid conflicts
+            prefixed_name = f"mcp_{name}"
+
+            return MCPTool(
+                name=prefixed_name,
+                description=description,
+                parameters=parameters,
+                mcp_manager=self._mcp_manager,
+                server_name=server_name,
+            )
+
+        except Exception as e:
+            print(f"Error creating MCP tool: {e}")
+            return None
+
+    def _map_type(self, mcp_type: str) -> str:
+        """Map MCP type to tool parameter type"""
+        type_map = {
+            "string": "string",
+            "str": "string",
+            "int": "integer",
+            "integer": "integer",
+            "float": "number",
+            "number": "number",
+            "bool": "boolean",
+            "boolean": "boolean",
+            "list": "array",
+            "array": "array",
+            "dict": "object",
+            "object": "object",
+        }
+        return type_map.get(mcp_type.lower(), "string")
+
+    def get_registered_tools(self) -> List[str]:
+        """Get list of registered MCP tool names"""
+        return list(self._registered_tools.keys())
+
+    def unregister_all(self) -> int:
+        """Unregister all MCP tools
+
+        Returns:
+            Number of tools unregistered
+        """
+        count = 0
+        for name in list(self._registered_tools.keys()):
+            if self.registry.unregister(name):
+                count += 1
+            del self._registered_tools[name]
+        return count
+
+
+def integrate_mcp_with_agent(agent, mcp_manager) -> MCPBridge:
+    """Integrate MCP tools with an agent
+
+    Args:
+        agent: Agent instance
+        mcp_manager: MCPManager instance
+
+    Returns:
+        MCPBridge instance
+    """
+    bridge = MCPBridge(agent.registry)
+    bridge.connect_mcp_manager(mcp_manager)
+    count = bridge.discover_and_register_tools()
+    print(f"Registered {count} MCP tools with agent")
+    return bridge

nc1709/agent/permissions.py

@@ -0,0 +1,298 @@
+"""
+Tool Permissions System
+
+Manages permissions for tool execution with configurable policies.
+"""
+
+import json
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+from .tools.base import ToolPermission, ToolRegistry
+
+
+class PermissionPolicy(Enum):
+    """Permission policies for different contexts"""
+    STRICT = "strict"       # Ask for everything
+    NORMAL = "normal"       # Ask for writes/executes, auto for reads
+    PERMISSIVE = "permissive"  # Auto-approve most, ask for dangerous
+    TRUST = "trust"         # Auto-approve everything
+
+
+@dataclass
+class PermissionRule:
+    """A rule for tool permissions"""
+    tool_pattern: str  # Tool name or pattern (supports wildcards)
+    permission: ToolPermission
+    reason: Optional[str] = None
+
+
+@dataclass
+class PermissionConfig:
+    """Configuration for the permissions system"""
+    policy: PermissionPolicy = PermissionPolicy.NORMAL
+    custom_rules: List[PermissionRule] = field(default_factory=list)
+    blocked_tools: Set[str] = field(default_factory=set)
+    session_approvals: Set[str] = field(default_factory=set)
+
+
+class PermissionManager:
+    """
+    Manages tool permissions with configurable policies.
+
+    Provides:
+    - Policy-based default permissions
+    - Custom per-tool rules
+    - Session-level approvals
+    - Blocking of dangerous tools
+    """
+
+    # Default permissions by policy
+    POLICY_DEFAULTS = {
+        PermissionPolicy.STRICT: {
+            "default": ToolPermission.ASK,
+            "auto": [],
+        },
+        PermissionPolicy.NORMAL: {
+            "default": ToolPermission.ASK,
+            "auto": ["Read", "Glob", "Grep", "Ripgrep", "TodoWrite"],
+        },
+        PermissionPolicy.PERMISSIVE: {
+            "default": ToolPermission.AUTO,
+            "ask": ["Bash", "Write", "Edit", "Task", "BackgroundBash"],
+        },
+        PermissionPolicy.TRUST: {
+            "default": ToolPermission.AUTO,
+            "ask": [],
+        },
+    }
+
+    def __init__(self, config: PermissionConfig = None):
+        """Initialize the permission manager
+
+        Args:
+            config: Permission configuration
+        """
+        self.config = config or PermissionConfig()
+        self._registry: Optional[ToolRegistry] = None
+
+    def attach_registry(self, registry: ToolRegistry) -> None:
+        """Attach a tool registry and apply permissions
+
+        Args:
+            registry: Tool registry to manage
+        """
+        self._registry = registry
+        self._apply_policy()
+        self._apply_custom_rules()
+
+    def _apply_policy(self) -> None:
+        """Apply the current policy to the registry"""
+        if not self._registry:
+            return
+
+        policy_config = self.POLICY_DEFAULTS.get(self.config.policy, {})
+        default_perm = policy_config.get("default", ToolPermission.ASK)
+
+        # Set default for all tools
+        for tool_name in self._registry.list_names():
+            self._registry.set_permission(tool_name, default_perm)
+
+        # Apply auto-approve list
+        for tool_name in policy_config.get("auto", []):
+            self._registry.set_permission(tool_name, ToolPermission.AUTO)
+
+        # Apply ask list
+        for tool_name in policy_config.get("ask", []):
+            self._registry.set_permission(tool_name, ToolPermission.ASK)
+
+    def _apply_custom_rules(self) -> None:
+        """Apply custom permission rules"""
+        if not self._registry:
+            return
+
+        for rule in self.config.custom_rules:
+            # Handle wildcards
+            if "*" in rule.tool_pattern:
+                import fnmatch
+                for tool_name in self._registry.list_names():
+                    if fnmatch.fnmatch(tool_name, rule.tool_pattern):
+                        self._registry.set_permission(tool_name, rule.permission)
+            else:
+                self._registry.set_permission(rule.tool_pattern, rule.permission)
+
+        # Apply blocked tools
+        for tool_name in self.config.blocked_tools:
+            self._registry.set_permission(tool_name, ToolPermission.DENY)
+
+    def set_policy(self, policy: PermissionPolicy) -> None:
+        """Change the permission policy
+
+        Args:
+            policy: New policy to apply
+        """
+        self.config.policy = policy
+        self._apply_policy()
+        self._apply_custom_rules()
+
+    def add_rule(self, rule: PermissionRule) -> None:
+        """Add a custom permission rule
+
+        Args:
+            rule: Rule to add
+        """
+        self.config.custom_rules.append(rule)
+        if self._registry:
+            self._apply_custom_rules()
+
+    def block_tool(self, tool_name: str) -> None:
+        """Block a tool from being used
+
+        Args:
+            tool_name: Tool to block
+        """
+        self.config.blocked_tools.add(tool_name)
+        if self._registry:
+            self._registry.set_permission(tool_name, ToolPermission.DENY)
+
+    def unblock_tool(self, tool_name: str) -> None:
+        """Unblock a tool
+
+        Args:
+            tool_name: Tool to unblock
+        """
+        self.config.blocked_tools.discard(tool_name)
+        if self._registry:
+            self._apply_policy()
+            self._apply_custom_rules()
+
+    def approve_for_session(self, tool_name: str) -> None:
+        """Approve a tool for the current session
+
+        Args:
+            tool_name: Tool to approve
+        """
+        self.config.session_approvals.add(tool_name)
+        if self._registry:
+            self._registry.approve_for_session(tool_name)
+
+    def clear_session_approvals(self) -> None:
+        """Clear all session approvals"""
+        self.config.session_approvals.clear()
+        if self._registry:
+            self._registry.clear_session_approvals()
+
+    def needs_approval(self, tool_name: str) -> bool:
+        """Check if a tool needs approval
+
+        Args:
+            tool_name: Tool to check
+
+        Returns:
+            True if approval is needed
+        """
+        if not self._registry:
+            return True
+
+        if tool_name in self.config.blocked_tools:
+            return True  # Will be denied
+
+        if tool_name in self.config.session_approvals:
+            return False
+
+        return self._registry.needs_approval(tool_name)
+
+    def get_permission(self, tool_name: str) -> ToolPermission:
+        """Get the current permission for a tool
+
+        Args:
+            tool_name: Tool name
+
+        Returns:
+            Current permission level
+        """
+        if tool_name in self.config.blocked_tools:
+            return ToolPermission.DENY
+
+        if self._registry:
+            return self._registry.get_permission(tool_name)
+
+        return ToolPermission.ASK
+
+    def get_status(self) -> Dict:
+        """Get current permission status
+
+        Returns:
+            Dict with permission information
+        """
+        tools_by_permission = {
+            "auto": [],
+            "ask": [],
+            "ask_once": [],
+            "deny": [],
+        }
+
+        if self._registry:
+            for tool_name in self._registry.list_names():
+                perm = self.get_permission(tool_name)
+                tools_by_permission[perm.value].append(tool_name)
+
+        return {
+            "policy": self.config.policy.value,
+            "tools": tools_by_permission,
+            "blocked": list(self.config.blocked_tools),
+            "session_approved": list(self.config.session_approvals),
+            "custom_rules": len(self.config.custom_rules),
+        }
+
+    def save_config(self, path: str) -> None:
+        """Save permission configuration to file
+
+        Args:
+            path: Path to save config
+        """
+        config_data = {
+            "policy": self.config.policy.value,
+            "custom_rules": [
+                {
+                    "tool_pattern": r.tool_pattern,
+                    "permission": r.permission.value,
+                    "reason": r.reason,
+                }
+                for r in self.config.custom_rules
+            ],
+            "blocked_tools": list(self.config.blocked_tools),
+        }
+
+        with open(path, "w") as f:
+            json.dump(config_data, f, indent=2)
+
+    @classmethod
+    def load_config(cls, path: str) -> "PermissionManager":
+        """Load permission configuration from file
+
+        Args:
+            path: Path to config file
+
+        Returns:
+            PermissionManager with loaded config
+        """
+        with open(path, "r") as f:
+            data = json.load(f)
+
+        config = PermissionConfig(
+            policy=PermissionPolicy(data.get("policy", "normal")),
+            custom_rules=[
+                PermissionRule(
+                    tool_pattern=r["tool_pattern"],
+                    permission=ToolPermission(r["permission"]),
+                    reason=r.get("reason"),
+                )
+                for r in data.get("custom_rules", [])
+            ],
+            blocked_tools=set(data.get("blocked_tools", [])),
+        )
+
+        return cls(config)

nc1709/agent/tools/__init__.py

@@ -0,0 +1,21 @@
+"""
+NC1709 Agent Tools
+
+Built-in tools for the agentic CLI:
+- File operations: Read, Write, Edit, Glob
+- Search operations: Grep, Ripgrep
+- Execution: Bash, BackgroundBash
+- Sub-agents: Task, TodoWrite, AskUser
+- Web: WebFetch, WebSearch, WebScreenshot
+- Notebook: NotebookRead, NotebookEdit, NotebookRun
+"""
+
+from .base import Tool, ToolResult, ToolRegistry, ToolPermission, ToolParameter
+
+__all__ = [
+    "Tool",
+    "ToolResult",
+    "ToolRegistry",
+    "ToolPermission",
+    "ToolParameter",
+]