agentic-fabriq-sdk 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

af_cli/commands/config.py

@@ -0,0 +1,102 @@
+"""
+Configuration commands for the Agentic Fabric CLI.
+"""
+
+import typer
+
+from af_cli.core.config import get_config
+from af_cli.core.output import error, info, print_output, success
+
+app = typer.Typer(help="Configuration commands")
+
+
+@app.command()
+def show(
+    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+):
+    """Show current configuration."""
+    config = get_config()
+    
+    config_data = {
+        "gateway_url": config.gateway_url,
+        "tenant_id": config.tenant_id or "Not set",
+        "authenticated": "Yes" if config.is_authenticated() else "No",
+        "config_file": config.config_file,
+        "output_format": config.output_format,
+    }
+    
+    print_output(
+        config_data,
+        format_type=format,
+        title="Configuration"
+    )
+
+
+@app.command()
+def set(
+    key: str = typer.Argument(..., help="Configuration key"),
+    value: str = typer.Argument(..., help="Configuration value"),
+):
+    """Set configuration value."""
+    config = get_config()
+    
+    valid_keys = {
+        "gateway_url": "gateway_url",
+        "tenant_id": "tenant_id",
+        "output_format": "output_format",
+    }
+    
+    if key not in valid_keys:
+        error(f"Invalid configuration key: {key}")
+        error(f"Valid keys: {', '.join(valid_keys.keys())}")
+        raise typer.Exit(1)
+    
+    # Set the value
+    setattr(config, valid_keys[key], value)
+    config.save()
+    
+    success(f"Configuration updated: {key} = {value}")
+
+
+@app.command()
+def get(
+    key: str = typer.Argument(..., help="Configuration key"),
+):
+    """Get configuration value."""
+    config = get_config()
+    
+    valid_keys = {
+        "gateway_url": "gateway_url",
+        "tenant_id": "tenant_id",
+        "output_format": "output_format",
+    }
+    
+    if key not in valid_keys:
+        error(f"Invalid configuration key: {key}")
+        error(f"Valid keys: {', '.join(valid_keys.keys())}")
+        raise typer.Exit(1)
+    
+    value = getattr(config, valid_keys[key])
+    info(f"{key}: {value}")
+
+
+@app.command()
+def reset():
+    """Reset configuration to defaults."""
+    config = get_config()
+    
+    if not typer.confirm("Are you sure you want to reset configuration to defaults?"):
+        info("Reset cancelled")
+        return
+    
+    # Clear authentication
+    config.clear_auth()
+    
+    # Reset to defaults
+    config.gateway_url = "http://localhost:8000"
+    config.tenant_id = None
+    config.output_format = "table"
+    
+    config.save()
+    
+    success("Configuration reset to defaults") 

af_cli/commands/mcp_servers.py

@@ -0,0 +1,83 @@
+"""
+MCP server management commands for the Agentic Fabric CLI.
+"""
+
+import typer
+
+from af_cli.core.client import get_client
+from af_cli.core.output import error, info, print_output, success, warning
+
+app = typer.Typer(help="MCP server management commands")
+
+
+@app.command()
+def list(
+    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+):
+    """List MCP servers."""
+    try:
+        with get_client() as client:
+            response = client.get("/api/v1/mcp-servers")
+            servers = response["servers"]
+            
+            if not servers:
+                warning("No MCP servers found")
+                return
+            
+            print_output(
+                servers,
+                format_type=format,
+                title="MCP Servers"
+            )
+            
+    except Exception as e:
+        error(f"Failed to list MCP servers: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def get(
+    server_id: str = typer.Argument(..., help="MCP server ID"),
+    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+):
+    """Get MCP server details."""
+    try:
+        with get_client() as client:
+            server = client.get(f"/api/v1/mcp-servers/{server_id}")
+            
+            print_output(
+                server,
+                format_type=format,
+                title=f"MCP Server {server_id}"
+            )
+            
+    except Exception as e:
+        error(f"Failed to get MCP server: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def create(
+    name: str = typer.Option(..., "--name", "-n", help="MCP server name"),
+    base_url: str = typer.Option(..., "--base-url", "-u", help="Base URL"),
+    auth_type: str = typer.Option("API_KEY", "--auth-type", "-a", help="Authentication type"),
+):
+    """Create a new MCP server."""
+    try:
+        with get_client() as client:
+            data = {
+                "name": name,
+                "base_url": base_url,
+                "auth_type": auth_type,
+                "source": "STATIC",
+            }
+            
+            server = client.post("/api/v1/mcp-servers", data)
+            
+            success(f"MCP server created: {server['id']}")
+            info(f"Name: {server['name']}")
+            info(f"Base URL: {server['base_url']}")
+            
+    except Exception as e:
+        error(f"Failed to create MCP server: {e}")
+        raise typer.Exit(1) 

af_cli/commands/secrets.py

@@ -0,0 +1,109 @@
+"""
+Secret management commands for the Agentic Fabric CLI.
+"""
+
+import typer
+
+from af_cli.core.client import get_client
+from af_cli.core.output import error, info, print_output, success
+
+app = typer.Typer(help="Secret management commands")
+
+
+@app.command()
+def get(
+    path: str = typer.Argument(..., help="Secret path"),
+    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+):
+    """Get a secret."""
+    try:
+        with get_client() as client:
+            secret = client.get(f"/api/v1/secrets/{path}")
+            
+            # Don't display the actual secret value in table format
+            if format == "table":
+                display_data = {
+                    "path": secret["path"],
+                    "description": secret.get("description", ""),
+                    "version": secret["version"],
+                    "created_at": secret["created_at"],
+                    "updated_at": secret["updated_at"],
+                }
+                print_output(display_data, format_type=format, title=f"Secret {path}")
+                info("Use --format=json to see the secret value")
+            else:
+                print_output(secret, format_type=format)
+            
+    except Exception as e:
+        error(f"Failed to get secret: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def create(
+    path: str = typer.Argument(..., help="Secret path"),
+    value: str = typer.Option(..., "--value", "-v", help="Secret value"),
+    description: str = typer.Option("", "--description", "-d", help="Secret description"),
+):
+    """Create a new secret."""
+    try:
+        with get_client() as client:
+            data = {
+                "value": value,
+                "description": description,
+            }
+            
+            secret = client.post(f"/api/v1/secrets/{path}", data)
+            
+            success(f"Secret created: {secret['path']}")
+            info(f"Version: {secret['version']}")
+            
+    except Exception as e:
+        error(f"Failed to create secret: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def update(
+    path: str = typer.Argument(..., help="Secret path"),
+    value: str = typer.Option(..., "--value", "-v", help="Secret value"),
+    description: str = typer.Option("", "--description", "-d", help="Secret description"),
+):
+    """Update a secret."""
+    try:
+        with get_client() as client:
+            data = {
+                "value": value,
+                "description": description,
+            }
+            
+            secret = client.put(f"/api/v1/secrets/{path}", data)
+            
+            success(f"Secret updated: {secret['path']}")
+            info(f"Version: {secret['version']}")
+            
+    except Exception as e:
+        error(f"Failed to update secret: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def delete(
+    path: str = typer.Argument(..., help="Secret path"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force deletion"),
+):
+    """Delete a secret."""
+    try:
+        if not force:
+            if not typer.confirm(f"Are you sure you want to delete secret {path}?"):
+                info("Deletion cancelled")
+                return
+        
+        with get_client() as client:
+            client.delete(f"/api/v1/secrets/{path}")
+            
+            success(f"Secret deleted: {path}")
+            
+    except Exception as e:
+        error(f"Failed to delete secret: {e}")
+        raise typer.Exit(1) 

af_cli/commands/tools.py

@@ -0,0 +1,83 @@
+"""
+Tool management commands for the Agentic Fabric CLI.
+"""
+
+
+import typer
+
+from af_cli.core.client import get_client
+from af_cli.core.output import error, info, print_output, success, warning
+
+app = typer.Typer(help="Tool management commands")
+
+
+@app.command()
+def list(
+    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+):
+    """List tools."""
+    try:
+        with get_client() as client:
+            response = client.get("/api/v1/tools")
+            tools = response["tools"]
+            
+            if not tools:
+                warning("No tools found")
+                return
+            
+            print_output(
+                tools,
+                format_type=format,
+                title="Tools"
+            )
+            
+    except Exception as e:
+        error(f"Failed to list tools: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def get(
+    tool_id: str = typer.Argument(..., help="Tool ID"),
+    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+):
+    """Get tool details."""
+    try:
+        with get_client() as client:
+            tool = client.get(f"/api/v1/tools/{tool_id}")
+            
+            print_output(
+                tool,
+                format_type=format,
+                title=f"Tool {tool_id}"
+            )
+            
+    except Exception as e:
+        error(f"Failed to get tool: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def invoke(
+    tool_id: str = typer.Argument(..., help="Tool ID"),
+    method: str = typer.Option(..., "--method", "-m", help="Tool method to invoke"),
+    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+):
+    """Invoke a tool."""
+    try:
+        with get_client() as client:
+            data = {
+                "method": method,
+                "parameters": {},
+                "context": {},
+            }
+            
+            info(f"Invoking tool {tool_id} method {method}...")
+            response = client.post(f"/api/v1/tools/{tool_id}/invoke", data)
+            
+            success("Tool invoked successfully")
+            print_output(response, format_type=format)
+            
+    except Exception as e:
+        error(f"Failed to invoke tool: {e}")
+        raise typer.Exit(1) 

af_cli/core/__init__.py

@@ -0,0 +1,3 @@
+"""
+Core utilities for the Agentic Fabric CLI.
+""" 

af_cli/core/client.py

@@ -0,0 +1,123 @@
+"""
+HTTP client for communicating with the Agentic Fabric Gateway.
+"""
+
+import json
+from typing import Any, Dict, Optional
+from urllib.parse import urljoin
+
+import httpx
+import typer
+
+from af_cli.core.config import get_config
+from af_cli.core.output import debug, error
+
+
+class AFClient:
+    """HTTP client for Agentic Fabric Gateway API."""
+    
+    def __init__(self, config: Optional[Dict] = None):
+        self.config = config or get_config()
+        self.client = httpx.Client(
+            base_url=self.config.gateway_url,
+            timeout=30.0,
+            follow_redirects=True,
+        )
+    
+    def _get_headers(self) -> Dict[str, str]:
+        """Get HTTP headers for requests."""
+        return self.config.get_headers()
+    
+    def _handle_response(self, response: httpx.Response) -> Dict[str, Any]:
+        """Handle HTTP response."""
+        debug(f"Response: {response.status_code} {response.url}")
+        
+        if response.status_code == 401:
+            error("Authentication failed. Please run 'af auth login'")
+            raise typer.Exit(1)
+        
+        if response.status_code == 403:
+            error("Access denied. Check your permissions.")
+            raise typer.Exit(1)
+        
+        if response.status_code >= 400:
+            try:
+                error_data = response.json()
+                error_message = error_data.get("message", "Unknown error")
+                error(f"API Error: {error_message}")
+                if self.config.verbose and "details" in error_data:
+                    debug(f"Error details: {json.dumps(error_data['details'], indent=2)}")
+            except:
+                error(f"HTTP Error: {response.status_code} {response.text}")
+            raise typer.Exit(1)
+        
+        try:
+            return response.json()
+        except:
+            return {"message": "Success"}
+    
+    def get(self, path: str, params: Optional[Dict] = None) -> Dict[str, Any]:
+        """Make GET request."""
+        url = urljoin(self.config.gateway_url, path)
+        debug(f"GET {url}")
+        
+        response = self.client.get(
+            path,
+            params=params,
+            headers=self._get_headers(),
+        )
+        
+        return self._handle_response(response)
+    
+    def post(self, path: str, data: Optional[Dict] = None) -> Dict[str, Any]:
+        """Make POST request."""
+        url = urljoin(self.config.gateway_url, path)
+        debug(f"POST {url}")
+        
+        response = self.client.post(
+            path,
+            json=data,
+            headers=self._get_headers(),
+        )
+        
+        return self._handle_response(response)
+    
+    def put(self, path: str, data: Optional[Dict] = None) -> Dict[str, Any]:
+        """Make PUT request."""
+        url = urljoin(self.config.gateway_url, path)
+        debug(f"PUT {url}")
+        
+        response = self.client.put(
+            path,
+            json=data,
+            headers=self._get_headers(),
+        )
+        
+        return self._handle_response(response)
+    
+    def delete(self, path: str) -> Dict[str, Any]:
+        """Make DELETE request."""
+        url = urljoin(self.config.gateway_url, path)
+        debug(f"DELETE {url}")
+        
+        response = self.client.delete(
+            path,
+            headers=self._get_headers(),
+        )
+        
+        return self._handle_response(response)
+    
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self.client.close()
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+def get_client() -> AFClient:
+    """Get HTTP client instance."""
+    return AFClient()