agentr 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

agentr/__init__.py

@@ -1,2 +1,2 @@
-def main():
+def main():
     print("hello")

agentr/application.py

@@ -1,50 +1,57 @@
-from abc import ABC, abstractmethod
-from agentr.store import Store
-import httpx
-
-class Application(ABC):
-    def __init__(self, name: str, **kwargs):
-        self.name = name
-
-    @abstractmethod
-    def list_tools(self):
-        pass
-
-
-class APIApplication(Application):
-    def __init__(self, name: str, store: Store, **kwargs):
-        super().__init__(name, **kwargs)
-        self.store = store
-
-    def _get_headers(self):
-        return {}
-    
-    def _get(self, url, params=None):
-        headers = self._get_headers()
-        response = httpx.get(url, headers=headers, params=params)
-        return response
-    
-    def _post(self, url, data):
-        headers = self._get_headers()
-        response = httpx.post(url, headers=headers, data=data)
-        return response
-
-    def _put(self, url, data):
-        headers = self._get_headers()
-        response = httpx.put(url, headers=headers, data=data)
-        return response
-
-    def _delete(self, url):
-        headers = self._get_headers()
-        response = httpx.delete(url, headers=headers)
-        return response
-
-    def validate(self):
-        pass
-    
-    def authorize(self):
-        pass
-
-    @abstractmethod
-    def list_tools(self):
+from abc import ABC, abstractmethod
+from agentr.integration import Integration
+import httpx
+
+class Application(ABC):
+    """
+    Application is collection of tools that can be used by an agent.
+    """
+    def __init__(self, name: str, **kwargs):
+        self.name = name
+
+    @abstractmethod
+    def list_tools(self):
+        pass
+
+
+class APIApplication(Application):
+    """
+    APIApplication is an application that uses an API to interact with the world.
+    """
+    def __init__(self, name: str, integration: Integration = None, **kwargs):
+        super().__init__(name, **kwargs)
+        self.integration = integration
+
+    def _get_headers(self):
+        return {}
+    
+    def _get(self, url, params=None):
+        headers = self._get_headers()
+        response = httpx.get(url, headers=headers, params=params)
+        response.raise_for_status()
+        return response
+    
+    def _post(self, url, data):
+        headers = self._get_headers()
+        response = httpx.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        return response
+
+    def _put(self, url, data):
+        headers = self._get_headers()
+        response = httpx.put(url, headers=headers, json=data)
+        response.raise_for_status()
+        return response
+
+    def _delete(self, url):
+        headers = self._get_headers()
+        response = httpx.delete(url, headers=headers)
+        response.raise_for_status()
+        return response
+
+    def validate(self):
+        pass
+    
+    @abstractmethod
+    def list_tools(self):
         pass

agentr/applications/github/app.py

@@ -0,0 +1,56 @@
+from agentr.integration import Integration
+from agentr.application import APIApplication
+from loguru import logger
+from agentr.exceptions import NotAuthorizedError
+
+class GithubApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="github", integration=integration)
+
+    def _get_headers(self):
+        if not self.integration:
+            raise ValueError("Integration not configured")
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            logger.warning("No credentials found")
+            action = self.integration.authorize()
+            raise NotAuthorizedError(action)
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/vnd.github.v3+json"
+        }
+    
+
+    def star_repository(self, repo_full_name: str) -> str:
+        """Star a GitHub repository
+        
+            Args:
+                repo_full_name: The full name of the repository (e.g. 'owner/repo')
+                
+            Returns:
+            
+                A confirmation message
+        """
+        try:
+            url = f"https://api.github.com/user/starred/{repo_full_name}"
+            response = self._put(url, data={})
+            
+            if response.status_code == 204:
+                return f"Successfully starred repository {repo_full_name}"
+            elif response.status_code == 404:
+                return f"Repository {repo_full_name} not found"
+            else:
+                logger.error(response.text)
+                return f"Error starring repository: {response.text}"
+        except NotAuthorizedError as e:
+            return e.message
+        except Exception as e:
+            logger.error(e)
+            raise e
+       
+
+    
+    def list_tools(self):
+        return [self.star_repository]

agentr/applications/google_calendar/app.py

@@ -0,0 +1,74 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+from loguru import logger
+from datetime import datetime, timedelta
+
+class GoogleCalendarApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="google-calendar", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            "Accept": "application/json"
+        }
+    
+    
+    def get_today_events(self) -> str:
+        """Get events from your Google Calendar for today
+        
+        Returns:
+            A formatted list of today's events or an error message
+        """
+        if not self.validate():
+            logger.warning("Connection not configured correctly")
+            return self.authorize()
+        
+        try:
+            # Get today's date in ISO format
+            today = datetime.now().date()
+            tomorrow = today + timedelta(days=1)
+            
+            # Format dates for API
+            time_min = f"{today.isoformat()}T00:00:00Z"
+            time_max = f"{tomorrow.isoformat()}T00:00:00Z"
+            
+            url = "https://www.googleapis.com/calendar/v3/calendars/primary/events"
+            params = {
+                "timeMin": time_min,
+                "timeMax": time_max,
+                "singleEvents": "true",
+                "orderBy": "startTime"
+            }
+            
+            response = self._get(url, params=params)
+            
+            if response.status_code == 200:
+                events = response.json().get("items", [])
+                if not events:
+                    return "No events scheduled for today."
+                
+                result = "Today's events:\n\n"
+                for event in events:
+                    start = event.get("start", {})
+                    start_time = start.get("dateTime", start.get("date", "All day"))
+                    if "T" in start_time:  # Format datetime
+                        start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                        start_time = start_dt.strftime("%I:%M %p")
+                    
+                    summary = event.get("summary", "Untitled event")
+                    result += f"- {start_time}: {summary}\n"
+                
+                return result
+            else:
+                logger.error(response.text)
+                return f"Error retrieving calendar events: {response.text}"
+        except Exception as e:
+            logger.error(e)
+            return f"Error retrieving calendar events: {e}"
+    
+    def list_tools(self):
+        return [self.get_today_events]

agentr/applications/google_mail/app.py

@@ -0,0 +1,68 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+from loguru import logger
+import base64
+from email.message import EmailMessage
+
+class GmailApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="gmail", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+            'Content-Type': 'application/json'
+        }
+
+    def send_email(self, to: str, subject: str, body: str) -> str:
+        """Send an email
+        
+        Args:
+            to: The email address of the recipient
+            subject: The subject of the email
+            body: The body of the email
+            
+        Returns:
+        
+            A confirmation message
+        """
+        if not self.validate():
+            logger.warning("Connection not configured correctly")
+            return self.authorize()
+        try:
+            url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
+            
+            # Create email in base64 encoded format
+            email_message = {
+                "raw": self._create_message(to, subject, body)
+            }
+            logger.info(email_message)
+            
+            # Use json parameter instead of data to properly format JSON
+            response = self._post(url, email_message)
+            
+            if response.status_code == 200:
+                return f"Successfully sent email to {to}"
+            else:
+                logger.error(response.text)
+                return f"Error sending email: {response.text}"
+        except Exception as e:
+            logger.error(e)
+            return f"Error sending email: {e}"
+            
+    def _create_message(self, to, subject, body):
+        message = EmailMessage()
+        message['to'] = to
+        message['from'] = "manojbajaj95@gmail.com"
+        message['subject'] = subject
+        message.set_content(body)
+        
+        # Encode as base64 string
+        raw = base64.urlsafe_b64encode(message.as_bytes()).decode()
+        return raw
+    
+    def list_tools(self):
+        return [self.send_email]

agentr/applications/reddit/app.py

@@ -0,0 +1,29 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class RedditApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="reddit", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if "headers" in credentials:
+            return credentials["headers"]
+        return {
+            "Authorization": f"Bearer {credentials['access_token']}",
+        }
+
+    def get_subreddit_posts(self, subreddit: str) -> str:
+        """Get the latest posts from a subreddit
+        
+        Args:
+            subreddit: The subreddit to get posts from
+            
+        Returns:
+            A list of posts from the subreddit
+        """
+        
+
+    def list_tools(self):
+        return []
+    

agentr/applications/resend/app.py

@@ -0,0 +1,43 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class ResendApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        super().__init__(name="resend", integration=integration)
+
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found")
+        return {
+            "Authorization": f"Bearer {credentials['api_key']}",
+        }
+
+    def send_email(self, to: str, subject: str, content: str) -> str:
+        """Send an email using the Resend API
+
+        Args:
+            to: The email address to send the email to
+            subject: The subject of the email
+            content: The content of the email
+            
+        Returns:
+            A message indicating that the email was sent successfully
+        """
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found")
+        from_email = credentials.get("from_email", "Manoj <manoj@agentr.dev>")
+        url = "https://api.resend.com/emails"
+        body = {
+            "from": from_email,
+            "to": [to],
+            "subject": subject,
+            "text": content
+        }
+        self._post(url, body)
+        return "Sent Successfully"
+
+    def list_tools(self):
+        return [self.send_email]
+

agentr/applications/tavily/app.py

@@ -0,0 +1,57 @@
+from agentr.application import APIApplication
+from agentr.integration import Integration
+
+class TavilyApp(APIApplication):
+    def __init__(self, integration: Integration) -> None:
+        name = "tavily"
+        self.base_url = "https://api.tavily.com"
+        super().__init__(name=name, integration=integration)
+    
+    def _get_headers(self):
+        credentials = self.integration.get_credentials()
+        if not credentials:
+            raise ValueError("No credentials found")
+        return {
+            "Authorization": f"Bearer {credentials['api_key']}",
+            "Content-Type": "application/json"
+        }
+
+    def search(self, query: str) -> str:
+        """Search the web using Tavily's search API
+        
+        Args:
+            query: The search query
+            
+        Returns:
+            str: A summary of search results
+        """
+        self.validate()
+        url = f"{self.base_url}/search"
+        payload = {
+            "query": query,
+            "topic": "general",
+            "search_depth": "basic",
+            "max_results": 3,
+            "include_answer": True,
+            "include_raw_content": False,
+            "include_images": False,
+            "include_image_descriptions": False,
+            "include_domains": [],
+            "exclude_domains": []
+        }
+        
+        response = self._post(url, payload)
+        result = response.json()
+        
+        if "answer" in result:
+            return result["answer"]
+        
+        # Fallback to combining top results if no direct answer
+        summaries = []
+        for item in result.get("results", [])[:3]:
+            summaries.append(f"• {item['title']}: {item['snippet']}")
+        
+        return "\n".join(summaries)
+    
+    def list_tools(self):
+        return [self.search]

agentr/applications/zenquotes/app.py

@@ -1,21 +1,21 @@
-from agentr.application import APIApplication
-
-
-class ZenQuoteApp(APIApplication):
-    def __init__(self, **kwargs) -> None:
-        super().__init__(name="zenquote", **kwargs)
-
-    def get_quote(self) -> str:
-        """Get an inspirational quote from the Zen Quotes API
-        
-        Returns:
-            A random inspirational quote
-        """
-        url = "https://zenquotes.io/api/random"
-        response = self._get(url)
-        data = response.json()
-        quote_data = data[0]
-        return f"{quote_data['q']} - {quote_data['a']}"
-
-    def list_tools(self):
+from agentr.application import APIApplication
+
+
+class ZenQuoteApp(APIApplication):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(name="zenquote", **kwargs)
+
+    def get_quote(self) -> str:
+        """Get an inspirational quote from the Zen Quotes API
+        
+        Returns:
+            A random inspirational quote
+        """
+        url = "https://zenquotes.io/api/random"
+        response = self._get(url)
+        data = response.json()
+        quote_data = data[0]
+        return f"{quote_data['q']} - {quote_data['a']}"
+
+    def list_tools(self):
         return [self.get_quote]

agentr/cli.py

@@ -1,35 +1,75 @@
-import typer
-import yaml
-from pathlib import Path
-
-app = typer.Typer()
-
-@app.command()
-def version():
-    """Show the version of the CLI"""
-    print("agentr version 0.1.0")
-
-@app.command()
-def generate(schema_path: Path = typer.Option(..., "--schema", "-s")):
-    """Generate API client from OpenAPI schema"""
-    if not schema_path.exists():
-        typer.echo(f"Error: Schema file {schema_path} does not exist", err=True)
-        raise typer.Exit(1)
-    from .utils.openapi import generate_api_client, load_schema
-
-    try:
-        schema = load_schema(schema_path)
-    except Exception as e:
-        typer.echo(f"Error loading schema: {e}", err=True)
-        raise typer.Exit(1)
-    code = generate_api_client(schema)
-    print(code)
-
-@app.command()
-def run():
-    """Run the MCP server"""
-    from agentr.mcp import mcp
-    mcp.run()
-
-if __name__ == "__main__":
-    app()
+import typer
+from pathlib import Path
+import sys
+
+app = typer.Typer()
+
+@app.command()
+def version():
+    """Show the version of the CLI"""
+    print("agentr version 0.1.0")
+
+@app.command()
+def generate(schema_path: Path = typer.Option(..., "--schema", "-s")):
+    """Generate API client from OpenAPI schema"""
+    if not schema_path.exists():
+        typer.echo(f"Error: Schema file {schema_path} does not exist", err=True)
+        raise typer.Exit(1)
+    from .utils.openapi import generate_api_client, load_schema
+
+    try:
+        schema = load_schema(schema_path)
+    except Exception as e:
+        typer.echo(f"Error loading schema: {e}", err=True)
+        raise typer.Exit(1)
+    code = generate_api_client(schema)
+    print(code)
+
+@app.command()
+def run():
+    """Run the MCP server"""
+    from agentr.test import mcp
+    mcp.run()
+
+@app.command()
+def install(app_name: str):
+    """Install an app"""
+    import json
+
+    # Print instructions before asking for API key
+    typer.echo("╭─ Instruction ─────────────────────────────────────────────────────────────────╮")
+    typer.echo("│ API key is required. Visit https://agentr.dev to create an API key.           │")
+    typer.echo("╰───────────────────────────────────────────────────────────────────────────────╯")
+    # Prompt for API key
+    api_key = typer.prompt("Enter your AgentR API key", hide_input=True)
+
+    if app_name == "claude":
+        typer.echo(f"Installing mcp server for: {app_name}")
+
+        # Determine platform-specific config path
+        if sys.platform == "darwin":  # macOS
+            config_path = Path.home() / "Library/Application Support/Claude/claude_desktop_config.json"
+        elif sys.platform == "win32":  # Windows
+            config_path = Path.home() / "AppData/Roaming/Claude/claude_desktop_config.json"
+        else:
+            typer.echo("Unsupported platform. Only macOS and Windows are currently supported.", err=True)
+            raise typer.Exit(1)
+        
+        
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        config['mcpServers']['agentr-r'] = {
+            "command": "uvx",
+            "args": ["agentr@latest", "run"],
+            "env": {
+                "AGENTR_API_KEY": api_key
+            }
+        }
+        with open(config_path, 'w') as f:
+            json.dump(config, f, indent=4)
+        typer.echo("App installed successfully")
+    else:
+        typer.echo(f"App {app_name} not supported")
+
+if __name__ == "__main__":
+    app()

agentr/exceptions.py

@@ -0,0 +1,5 @@
+class NotAuthorizedError(Exception):
+    """Raised when a user is not authorized to access a resource or perform an action."""
+    def __init__(self, message="Not authorized to perform this action"):
+        self.message = message
+        super().__init__(self.message)