omnipalm 0.1.0__py3-none-any.whl

omnipalm/__init__.py

@@ -0,0 +1,15 @@
+"""
+OmniPalm - Meta's AI Agent
+
+Automate tasks across Meta's ecosystem with natural language.
+"""
+
+__version__ = "0.1.0"
+__author__ = "OmniPalm Team"
+__email__ = "hello@omnipalm.org"
+
+from omnipalm.agent import Agent
+from omnipalm.config import Config
+from omnipalm.integrations import Integration
+
+__all__ = ["Agent", "Config", "Integration", "__version__"]

omnipalm/agent.py

@@ -0,0 +1,96 @@
+"""
+OmniPalm Agent - The core AI agent for task automation.
+"""
+
+from typing import Any, Optional
+from pydantic import BaseModel
+from omnipalm.config import Config
+from omnipalm.integrations import IntegrationManager
+
+
+class TaskResult(BaseModel):
+    """Result of an agent task execution."""
+    success: bool
+    message: str
+    data: Optional[dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+class Agent:
+    """
+    OmniPalm AI Agent.
+    
+    Automate tasks across Meta's ecosystem using natural language commands.
+    
+    Example:
+        >>> agent = Agent()
+        >>> result = agent.run("Post to Facebook: Hello world!")
+        >>> print(result.success)
+        True
+    """
+    
+    def __init__(self, config: Optional[Config] = None):
+        """
+        Initialize the OmniPalm agent.
+        
+        Args:
+            config: Optional configuration. If not provided, loads from default locations.
+        """
+        self.config = config or Config.load()
+        self.integrations = IntegrationManager(self.config)
+        self._initialized = False
+    
+    def init(self) -> None:
+        """Initialize the agent and all configured integrations."""
+        self.integrations.init_all()
+        self._initialized = True
+    
+    def run(self, task: str) -> TaskResult:
+        """
+        Execute a natural language task.
+        
+        Args:
+            task: Natural language description of the task to perform.
+            
+        Returns:
+            TaskResult containing success status, message, and any data.
+            
+        Example:
+            >>> result = agent.run("Schedule an Instagram post for tomorrow")
+            >>> print(result.message)
+            'Post scheduled for 2026-02-06 09:00'
+        """
+        if not self._initialized:
+            self.init()
+        
+        # Parse and execute the task
+        try:
+            result = self._execute_task(task)
+            return TaskResult(
+                success=True,
+                message=result.get("message", "Task completed successfully"),
+                data=result.get("data")
+            )
+        except Exception as e:
+            return TaskResult(
+                success=False,
+                message="Task failed",
+                error=str(e)
+            )
+    
+    def _execute_task(self, task: str) -> dict[str, Any]:
+        """Internal task execution logic."""
+        # This would connect to the LLM and execute the task
+        # Placeholder for actual implementation
+        return {
+            "message": f"Task received: {task}",
+            "data": {"status": "pending"}
+        }
+    
+    def status(self) -> dict[str, Any]:
+        """Get the current status of the agent and integrations."""
+        return {
+            "initialized": self._initialized,
+            "integrations": self.integrations.status(),
+            "config": self.config.summary()
+        }

omnipalm/cli.py

@@ -0,0 +1,90 @@
+"""
+OmniPalm CLI - Command line interface for OmniPalm.
+"""
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+
+@click.group()
+@click.version_option(package_name="omnipalm")
+def main():
+    """OmniPalm - Meta's AI Agent for task automation."""
+    pass
+
+
+@main.command()
+def init():
+    """Initialize OmniPalm configuration."""
+    from omnipalm.config import Config
+    
+    config = Config()
+    config.save()
+    
+    console.print(Panel.fit(
+        "[green]✓[/green] OmniPalm initialized successfully!\n\n"
+        f"Config saved to: [cyan]{config.data_dir}/config.yaml[/cyan]\n\n"
+        "Next steps:\n"
+        "  1. Add your LLM API key to the config\n"
+        "  2. Configure your Meta integrations\n"
+        "  3. Run [cyan]omnipalm run 'your task'[/cyan]",
+        title="OmniPalm",
+        border_style="cyan"
+    ))
+
+
+@main.command()
+@click.argument("task")
+def run(task: str):
+    """Run a natural language task."""
+    from omnipalm import Agent
+    
+    with console.status("[cyan]Processing task...[/cyan]"):
+        agent = Agent()
+        result = agent.run(task)
+    
+    if result.success:
+        console.print(f"[green]✓[/green] {result.message}")
+        if result.data:
+            console.print(result.data)
+    else:
+        console.print(f"[red]✗[/red] {result.message}")
+        if result.error:
+            console.print(f"[red]Error:[/red] {result.error}")
+
+
+@main.command()
+def status():
+    """Check OmniPalm status and integrations."""
+    from omnipalm import Agent
+    
+    agent = Agent()
+    status_info = agent.status()
+    
+    table = Table(title="OmniPalm Status")
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="green")
+    
+    table.add_row("Initialized", str(status_info["initialized"]))
+    table.add_row("LLM Provider", status_info["config"]["llm_provider"])
+    table.add_row("LLM Model", status_info["config"]["llm_model"])
+    
+    integrations = status_info["config"]["integrations_enabled"]
+    table.add_row("Integrations", ", ".join(integrations) if integrations else "None")
+    
+    console.print(table)
+
+
+@main.command()
+def version():
+    """Show OmniPalm version."""
+    from omnipalm import __version__
+    console.print(f"OmniPalm v{__version__}")
+
+
+if __name__ == "__main__":
+    main()

omnipalm/config.py

@@ -0,0 +1,108 @@
+"""
+OmniPalm Configuration Management.
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Optional
+from pydantic import BaseModel
+from dotenv import load_dotenv
+
+
+class LLMConfig(BaseModel):
+    """LLM provider configuration."""
+    provider: str = "anthropic"
+    model: str = "claude-3-opus"
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+
+class IntegrationConfig(BaseModel):
+    """Individual integration configuration."""
+    enabled: bool = False
+    access_token: Optional[str] = None
+    settings: dict[str, Any] = {}
+
+
+class Config(BaseModel):
+    """
+    OmniPalm configuration.
+    
+    Manages LLM provider settings and integration configurations.
+    """
+    llm: LLMConfig = LLMConfig()
+    integrations: dict[str, IntegrationConfig] = {}
+    data_dir: Path = Path.home() / ".omnipalm"
+    
+    @classmethod
+    def load(cls, path: Optional[Path] = None) -> "Config":
+        """
+        Load configuration from file or environment.
+        
+        Args:
+            path: Optional path to config file. Defaults to ~/.omnipalm/config.yaml
+            
+        Returns:
+            Config instance with loaded settings.
+        """
+        load_dotenv()
+        
+        config_path = path or Path.home() / ".omnipalm" / "config.yaml"
+        
+        if config_path.exists():
+            return cls._load_from_file(config_path)
+        
+        # Load from environment variables
+        return cls._load_from_env()
+    
+    @classmethod
+    def _load_from_file(cls, path: Path) -> "Config":
+        """Load configuration from YAML file."""
+        try:
+            import yaml
+            with open(path) as f:
+                data = yaml.safe_load(f)
+            return cls(**data)
+        except ImportError:
+            # YAML not available, use defaults
+            return cls()
+        except Exception:
+            return cls()
+    
+    @classmethod
+    def _load_from_env(cls) -> "Config":
+        """Load configuration from environment variables."""
+        llm_config = LLMConfig(
+            provider=os.getenv("OMNIPALM_LLM_PROVIDER", "anthropic"),
+            model=os.getenv("OMNIPALM_LLM_MODEL", "claude-3-opus"),
+            api_key=os.getenv("OMNIPALM_API_KEY"),
+        )
+        
+        return cls(llm=llm_config)
+    
+    def save(self, path: Optional[Path] = None) -> None:
+        """Save configuration to file."""
+        config_path = path or self.data_dir / "config.yaml"
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            import yaml
+            with open(config_path, "w") as f:
+                yaml.dump(self.model_dump(), f, default_flow_style=False)
+        except ImportError:
+            # Fallback to JSON
+            import json
+            config_path = config_path.with_suffix(".json")
+            with open(config_path, "w") as f:
+                json.dump(self.model_dump(), f, indent=2)
+    
+    def summary(self) -> dict[str, Any]:
+        """Get a summary of the configuration (without sensitive data)."""
+        return {
+            "llm_provider": self.llm.provider,
+            "llm_model": self.llm.model,
+            "integrations_enabled": [
+                name for name, cfg in self.integrations.items() if cfg.enabled
+            ],
+            "data_dir": str(self.data_dir),
+        }

omnipalm/integrations/__init__.py

@@ -0,0 +1,23 @@
+"""
+OmniPalm Integrations - Connect to Meta's ecosystem.
+"""
+
+from omnipalm.integrations.base import Integration
+from omnipalm.integrations.manager import IntegrationManager
+from omnipalm.integrations.facebook import FacebookIntegration
+from omnipalm.integrations.instagram import InstagramIntegration
+from omnipalm.integrations.whatsapp import WhatsAppIntegration
+from omnipalm.integrations.messenger import MessengerIntegration
+from omnipalm.integrations.threads import ThreadsIntegration
+from omnipalm.integrations.workplace import WorkplaceIntegration
+
+__all__ = [
+    "Integration",
+    "IntegrationManager",
+    "FacebookIntegration",
+    "InstagramIntegration",
+    "WhatsAppIntegration",
+    "MessengerIntegration",
+    "ThreadsIntegration",
+    "WorkplaceIntegration",
+]

omnipalm/integrations/base.py

@@ -0,0 +1,85 @@
+"""
+Base Integration class for OmniPalm.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+from pydantic import BaseModel
+
+
+class IntegrationStatus(BaseModel):
+    """Status of an integration."""
+    name: str
+    enabled: bool
+    connected: bool
+    error: Optional[str] = None
+
+
+class Integration(ABC):
+    """
+    Base class for all OmniPalm integrations.
+    
+    Subclasses must implement the connect, disconnect, and execute methods.
+    """
+    
+    name: str = "base"
+    description: str = "Base integration"
+    
+    def __init__(self, config: dict[str, Any]):
+        """
+        Initialize the integration.
+        
+        Args:
+            config: Integration-specific configuration.
+        """
+        self.config = config
+        self._connected = False
+        self._error: Optional[str] = None
+    
+    @property
+    def enabled(self) -> bool:
+        """Check if integration is enabled."""
+        return self.config.get("enabled", False)
+    
+    @property
+    def connected(self) -> bool:
+        """Check if integration is connected."""
+        return self._connected
+    
+    @abstractmethod
+    def connect(self) -> bool:
+        """
+        Connect to the integration service.
+        
+        Returns:
+            True if connection successful, False otherwise.
+        """
+        pass
+    
+    @abstractmethod
+    def disconnect(self) -> None:
+        """Disconnect from the integration service."""
+        pass
+    
+    @abstractmethod
+    def execute(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute an action on the integration.
+        
+        Args:
+            action: The action to perform (e.g., 'post', 'send', 'schedule').
+            params: Action-specific parameters.
+            
+        Returns:
+            Result of the action execution.
+        """
+        pass
+    
+    def status(self) -> IntegrationStatus:
+        """Get the current status of the integration."""
+        return IntegrationStatus(
+            name=self.name,
+            enabled=self.enabled,
+            connected=self._connected,
+            error=self._error
+        )

omnipalm/integrations/facebook.py

@@ -0,0 +1,77 @@
+"""
+Facebook Integration for OmniPalm.
+"""
+
+from typing import Any
+from omnipalm.integrations.base import Integration
+
+
+class FacebookIntegration(Integration):
+    """
+    Facebook Page integration.
+    
+    Supports posting, scheduling, comment management, and insights.
+    """
+    
+    name = "facebook"
+    description = "Facebook Page management and automation"
+    
+    def connect(self) -> bool:
+        """Connect to Facebook Graph API."""
+        access_token = self.config.get("access_token")
+        if not access_token:
+            self._error = "No access token configured"
+            return False
+        
+        # Validate token with Facebook API
+        # Placeholder for actual implementation
+        self._connected = True
+        return True
+    
+    def disconnect(self) -> None:
+        """Disconnect from Facebook."""
+        self._connected = False
+    
+    def execute(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute a Facebook action.
+        
+        Supported actions:
+            - post: Create a new post
+            - schedule: Schedule a post
+            - comment: Reply to a comment
+            - insights: Get page insights
+        """
+        if not self._connected:
+            return {"error": "Not connected to Facebook"}
+        
+        actions = {
+            "post": self._post,
+            "schedule": self._schedule,
+            "comment": self._comment,
+            "insights": self._insights,
+        }
+        
+        handler = actions.get(action)
+        if not handler:
+            return {"error": f"Unknown action: {action}"}
+        
+        return handler(params)
+    
+    def _post(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Create a Facebook post."""
+        message = params.get("message", "")
+        # API call placeholder
+        return {"success": True, "post_id": "123456789", "message": message}
+    
+    def _schedule(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Schedule a Facebook post."""
+        return {"success": True, "scheduled": True}
+    
+    def _comment(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Reply to a comment."""
+        return {"success": True, "comment_id": "987654321"}
+    
+    def _insights(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Get page insights."""
+        return {"success": True, "reach": 0, "engagement": 0}

omnipalm/integrations/instagram.py

@@ -0,0 +1,37 @@
+"""
+Instagram Integration for OmniPalm.
+"""
+
+from typing import Any
+from omnipalm.integrations.base import Integration
+
+
+class InstagramIntegration(Integration):
+    """
+    Instagram Business integration.
+    
+    Supports posting photos/reels, stories, DMs, and insights.
+    """
+    
+    name = "instagram"
+    description = "Instagram content and engagement automation"
+    
+    def connect(self) -> bool:
+        """Connect to Instagram Graph API."""
+        access_token = self.config.get("access_token")
+        if not access_token:
+            self._error = "No access token configured"
+            return False
+        self._connected = True
+        return True
+    
+    def disconnect(self) -> None:
+        """Disconnect from Instagram."""
+        self._connected = False
+    
+    def execute(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Execute an Instagram action."""
+        if not self._connected:
+            return {"error": "Not connected to Instagram"}
+        
+        return {"success": True, "action": action, "params": params}

omnipalm/integrations/manager.py

@@ -0,0 +1,82 @@
+"""
+Integration Manager for OmniPalm.
+"""
+
+from typing import Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from omnipalm.config import Config
+
+
+class IntegrationManager:
+    """
+    Manages all OmniPalm integrations.
+    
+    Handles initialization, connection, and routing of actions to integrations.
+    """
+    
+    def __init__(self, config: "Config"):
+        """
+        Initialize the integration manager.
+        
+        Args:
+            config: OmniPalm configuration.
+        """
+        self.config = config
+        self._integrations: dict[str, Any] = {}
+    
+    def init_all(self) -> None:
+        """Initialize all enabled integrations."""
+        from omnipalm.integrations import (
+            FacebookIntegration,
+            InstagramIntegration,
+            WhatsAppIntegration,
+            MessengerIntegration,
+            ThreadsIntegration,
+            WorkplaceIntegration,
+        )
+        
+        integration_classes = {
+            "facebook": FacebookIntegration,
+            "instagram": InstagramIntegration,
+            "whatsapp": WhatsAppIntegration,
+            "messenger": MessengerIntegration,
+            "threads": ThreadsIntegration,
+            "workplace": WorkplaceIntegration,
+        }
+        
+        for name, cls in integration_classes.items():
+            int_config = self.config.integrations.get(name)
+            if int_config and int_config.enabled:
+                integration = cls(int_config.model_dump())
+                if integration.connect():
+                    self._integrations[name] = integration
+    
+    def get(self, name: str) -> Optional[Any]:
+        """Get an integration by name."""
+        return self._integrations.get(name)
+    
+    def execute(self, integration_name: str, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute an action on a specific integration.
+        
+        Args:
+            integration_name: Name of the integration.
+            action: Action to perform.
+            params: Action parameters.
+            
+        Returns:
+            Result of the action.
+        """
+        integration = self.get(integration_name)
+        if not integration:
+            return {"error": f"Integration '{integration_name}' not found or not enabled"}
+        
+        return integration.execute(action, params)
+    
+    def status(self) -> dict[str, Any]:
+        """Get status of all integrations."""
+        return {
+            name: integration.status().model_dump()
+            for name, integration in self._integrations.items()
+        }

omnipalm/integrations/messenger.py

@@ -0,0 +1,27 @@
+"""Messenger Integration for OmniPalm."""
+
+from typing import Any
+from omnipalm.integrations.base import Integration
+
+
+class MessengerIntegration(Integration):
+    """Messenger Platform integration."""
+    
+    name = "messenger"
+    description = "Messenger chatbot and messaging automation"
+    
+    def connect(self) -> bool:
+        access_token = self.config.get("access_token")
+        if not access_token:
+            self._error = "No access token configured"
+            return False
+        self._connected = True
+        return True
+    
+    def disconnect(self) -> None:
+        self._connected = False
+    
+    def execute(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        if not self._connected:
+            return {"error": "Not connected to Messenger"}
+        return {"success": True, "action": action, "params": params}

omnipalm/integrations/threads.py

@@ -0,0 +1,27 @@
+"""Threads Integration for OmniPalm."""
+
+from typing import Any
+from omnipalm.integrations.base import Integration
+
+
+class ThreadsIntegration(Integration):
+    """Threads social platform integration."""
+    
+    name = "threads"
+    description = "Threads posting and engagement automation"
+    
+    def connect(self) -> bool:
+        access_token = self.config.get("access_token")
+        if not access_token:
+            self._error = "No access token configured"
+            return False
+        self._connected = True
+        return True
+    
+    def disconnect(self) -> None:
+        self._connected = False
+    
+    def execute(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        if not self._connected:
+            return {"error": "Not connected to Threads"}
+        return {"success": True, "action": action, "params": params}

omnipalm/integrations/whatsapp.py

@@ -0,0 +1,27 @@
+"""WhatsApp Business Integration for OmniPalm."""
+
+from typing import Any
+from omnipalm.integrations.base import Integration
+
+
+class WhatsAppIntegration(Integration):
+    """WhatsApp Business API integration."""
+    
+    name = "whatsapp"
+    description = "WhatsApp Business messaging automation"
+    
+    def connect(self) -> bool:
+        access_token = self.config.get("access_token")
+        if not access_token:
+            self._error = "No access token configured"
+            return False
+        self._connected = True
+        return True
+    
+    def disconnect(self) -> None:
+        self._connected = False
+    
+    def execute(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        if not self._connected:
+            return {"error": "Not connected to WhatsApp"}
+        return {"success": True, "action": action, "params": params}

omnipalm/integrations/workplace.py

@@ -0,0 +1,27 @@
+"""Workplace Integration for OmniPalm."""
+
+from typing import Any
+from omnipalm.integrations.base import Integration
+
+
+class WorkplaceIntegration(Integration):
+    """Workplace from Meta integration."""
+    
+    name = "workplace"
+    description = "Workplace internal communication automation"
+    
+    def connect(self) -> bool:
+        access_token = self.config.get("access_token")
+        if not access_token:
+            self._error = "No access token configured"
+            return False
+        self._connected = True
+        return True
+    
+    def disconnect(self) -> None:
+        self._connected = False
+    
+    def execute(self, action: str, params: dict[str, Any]) -> dict[str, Any]:
+        if not self._connected:
+            return {"error": "Not connected to Workplace"}
+        return {"success": True, "action": action, "params": params}

omnipalm-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: omnipalm
+Version: 0.1.0
+Summary: Meta's AI Agent - Automate tasks across Meta's ecosystem with natural language
+Project-URL: Homepage, https://omnipalm.org
+Project-URL: Documentation, https://omnipalm.org/documentation.html
+Project-URL: Repository, https://x.com/omnipalm
+Project-URL: Instagram, https://www.instagram.com/omni.palm
+Author-email: OmniPalm Team <hello@omnipalm.org>
+Maintainer-email: OmniPalm Team <hello@omnipalm.org>
+License: Proprietary
+License-File: LICENSE
+Keywords: agent,ai,automation,facebook,instagram,llm,meta,whatsapp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: click>=8.1.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# OmniPalm
+
+**Meta's AI Agent** - Automate tasks across Meta's ecosystem with natural language.
+
+## Installation
+
+```bash
+pip install omnipalm
+```
+
+## Quick Start
+
+```python
+from omnipalm import Agent
+
+agent = Agent()
+result = agent.run("Post to Instagram: Check out our new product!")
+print(result)
+```
+
+## CLI Usage
+
+```bash
+# Initialize configuration
+omnipalm init
+
+# Run a task
+omnipalm run "Schedule a Facebook post for tomorrow at 9am"
+
+# Check status
+omnipalm status
+```
+
+## Features
+
+- **Natural Language Commands** - Just describe what you want to do
+- **Meta Integrations** - Facebook, Instagram, WhatsApp, Messenger, Threads, Workplace, Meta Quest
+- **Multiple LLM Providers** - Claude, GPT-4, Gemini, Llama, and local models
+- **Enterprise Ready** - Built for scale with Meta's infrastructure
+
+## Configuration
+
+Create a `.omnipalm.yaml` file:
+
+```yaml
+llm:
+  provider: anthropic
+  model: claude-3-opus
+
+integrations:
+  facebook:
+    enabled: true
+    page_id: your-page-id
+  instagram:
+    enabled: true
+    business_account_id: your-account-id
+```
+
+## Links
+
+- Website: https://omnipalm.org
+- X (Twitter): https://x.com/omnipalm
+- Instagram: https://www.instagram.com/omni.palm
+
+## License
+
+Proprietary - Meta Platforms, Inc.

omnipalm-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+omnipalm/__init__.py,sha256=NsYSU7uDs7VF2QMeiTRpvs9EXD6s1gvFrVgAlXEnIz4,359
+omnipalm/agent.py,sha256=6pNxqfz6fARo3vbZjZeX8tbja2yUSW4QDFbJITtLSpw,2904
+omnipalm/cli.py,sha256=0IY3kLYiNMASmt1z4oGxaydtGwGOJPBpxG4nRBXRjNo,2371
+omnipalm/config.py,sha256=vDaGjEWNqrttc0sZzUBsMooC0mM11ItI4fNvFvF2lbQ,3333
+omnipalm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omnipalm/integrations/__init__.py,sha256=L8V5l6tvg2IsxRlq4fWjq4AGJMilK1w4Dtvf39Hj5UI,780
+omnipalm/integrations/base.py,sha256=LdIuDsL0Y6V14TxBiQWhbOZ9W0_071qPpEb8MSt39Ug,2155
+omnipalm/integrations/facebook.py,sha256=3_q1kAQHnYlJ2ce4x_9enXB-zQ1Lp0Jy6lakv9BMBWQ,2416
+omnipalm/integrations/instagram.py,sha256=0HaMbKESuoxVmT5xqcu9f2jvG2wMe1XhTI-b7LwbREk,1078
+omnipalm/integrations/manager.py,sha256=i_eS2p7FGvN7VI5d8gzzp4Eu2WCB-lZOkQ9X6MZGaGo,2579
+omnipalm/integrations/messenger.py,sha256=wmuxWCZ2kf2ASe4z6oLf7-64bFvgG4xHQ2oSkyHAjfM,858
+omnipalm/integrations/threads.py,sha256=iRZO2ti39Q2BsrhM2zYTrTm4Cuc1UfZK0Q1qn3W9m1I,854
+omnipalm/integrations/whatsapp.py,sha256=JAkYP8oNQhwGpR5zW3rrrEFfxnawra-baHSLidV5KRI,862
+omnipalm/integrations/workplace.py,sha256=li-92eKkYVCm4QpxxDcazj_u9UT0lDV5merwM7VJd0g,860
+omnipalm-0.1.0.dist-info/METADATA,sha256=pwfEBqGlC3Zri9mq_1cir2Xpgp9OghLDa-mYQK1tgQU,2854
+omnipalm-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+omnipalm-0.1.0.dist-info/entry_points.txt,sha256=vZNSMLrwQe1uVW2Ed76xQ4cZR5hlZmWEoOqV7hPAxrk,47
+omnipalm-0.1.0.dist-info/licenses/LICENSE,sha256=rTh0tIq5uFxzs8-THfF3i4Hwy2yIBs10Kp6oSLCxWAY,292
+omnipalm-0.1.0.dist-info/RECORD,,

omnipalm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

omnipalm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+omnipalm = omnipalm.cli:main

omnipalm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2026 OmniPalm / Meta Platforms, Inc.
+
+All rights reserved.
+
+This software is proprietary and confidential. Unauthorized copying, 
+modification, distribution, or use of this software, via any medium, 
+is strictly prohibited.
+
+For licensing inquiries, contact: hello@omnipalm.org