wingman-ai 1.0.0__py3-none-any.whl

wingman/cli/main.py

@@ -0,0 +1,50 @@
+"""Main CLI entry point for Wingman."""
+
+import typer
+from rich.console import Console
+
+from wingman import __version__
+
+from .commands import auth, config, init, logs, start, status, stop, uninstall
+
+# Create main app
+app = typer.Typer(
+    name="wingman",
+    help="Wingman - AI-powered personal chat agent for WhatsApp and iMessage",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# Rich console for pretty output
+console = Console()
+
+# Add subcommands
+app.command()(init.init)
+app.command()(auth.auth)
+app.command()(start.start)
+app.command()(stop.stop)
+app.command()(status.status)
+app.command()(logs.logs)
+app.command()(config.config)
+app.command()(uninstall.uninstall)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-v",
+        help="Show version and exit",
+        is_eager=True,
+    ),
+) -> None:
+    """Wingman - AI-powered personal chat agent."""
+    if version:
+        console.print(f"Wingman v{__version__}")
+        raise typer.Exit()
+
+
+if __name__ == "__main__":
+    app()

wingman/cli/wizard.py

@@ -0,0 +1,356 @@
+"""Interactive setup wizard for Wingman."""
+
+import re
+
+import questionary
+import yaml
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from wingman.config.paths import WingmanPaths
+from wingman.installer import NodeInstaller
+
+
+class SetupWizard:
+    """Interactive setup wizard for Wingman."""
+
+    def __init__(self, paths: WingmanPaths, console: Console):
+        self.paths = paths
+        self.console = console
+
+    def run(self) -> bool:
+        """Run the setup wizard. Returns True if setup completed successfully."""
+        # Step 1: Check prerequisites
+        if not self._check_prerequisites():
+            return False
+
+        # Step 2: OpenAI configuration
+        api_key = self._get_openai_config()
+        if not api_key:
+            return False
+
+        # Step 3: Bot personality
+        bot_name, personality_desc, tone = self._get_personality_config()
+
+        # Step 4: Safety settings
+        safety_config = self._get_safety_config()
+
+        # Step 5: Install Node.js listener
+        if not self._install_node_listener():
+            return False
+
+        # Generate config files
+        self._generate_configs(api_key, bot_name, personality_desc, tone, safety_config)
+
+        return True
+
+    def _check_prerequisites(self) -> bool:
+        """Check system prerequisites."""
+        self.console.print("[bold]Step 1/5: Checking prerequisites...[/bold]")
+        self.console.print()
+
+        installer = NodeInstaller(self.paths.node_dir)
+        all_ok, issues = installer.check_prerequisites()
+
+        # Python check (always passes if we're running)
+        import sys
+
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        self.console.print(f"  [green]✓[/green] Python {python_version}")
+
+        # Node.js check
+        version_info = installer.get_version_info()
+        if version_info["node_version"]:
+            self.console.print(f"  [green]✓[/green] Node.js {version_info['node_version']}")
+        else:
+            self.console.print("  [red]✗[/red] Node.js not found")
+
+        # npm check
+        if version_info["npm_version"]:
+            self.console.print(f"  [green]✓[/green] npm {version_info['npm_version']}")
+        else:
+            self.console.print("  [red]✗[/red] npm not found")
+
+        self.console.print()
+
+        if not all_ok:
+            self.console.print("[red]Prerequisites not met:[/red]")
+            for issue in issues:
+                self.console.print(f"  - {issue}")
+            self.console.print()
+            self.console.print("Please install the missing prerequisites and try again.")
+            return False
+
+        return True
+
+    def _get_openai_config(self) -> str | None:
+        """Get OpenAI API key from user."""
+        self.console.print("[bold]Step 2/5: OpenAI Configuration[/bold]")
+        self.console.print()
+
+        api_key = questionary.password(
+            "Enter your OpenAI API key:", instruction="(starts with 'sk-')"
+        ).ask()
+
+        if not api_key:
+            return None
+
+        # Validate API key format
+        if not api_key.startswith("sk-"):
+            self.console.print(
+                "[yellow]Warning: API key doesn't start with 'sk-'. Proceeding anyway.[/yellow]"
+            )
+
+        # Optional: Test API key
+        test = questionary.confirm("Test API key?", default=True).ask()
+
+        if test:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=self.console,
+            ) as progress:
+                progress.add_task("Testing API key...", total=None)
+
+                if self._test_api_key(api_key):
+                    self.console.print("  [green]✓[/green] API key is valid")
+                else:
+                    self.console.print("  [red]✗[/red] API key test failed")
+                    proceed = questionary.confirm("Continue anyway?", default=False).ask()
+                    if not proceed:
+                        return None
+
+        self.console.print()
+        return api_key
+
+    def _test_api_key(self, api_key: str) -> bool:
+        """Test if the OpenAI API key is valid."""
+        try:
+            from openai import OpenAI
+
+            client = OpenAI(api_key=api_key)
+            # Simple test - list models
+            client.models.list()
+            return True
+        except Exception:
+            return False
+
+    def _get_personality_config(self) -> tuple[str, str, str]:
+        """Get bot personality configuration."""
+        self.console.print("[bold]Step 3/5: Bot Personality[/bold]")
+        self.console.print()
+
+        bot_name = (
+            questionary.text("What should your bot be called?", default="Wingman").ask()
+            or "Wingman"
+        )
+
+        personality_desc = (
+            questionary.text(
+                "Describe your bot's personality:", default="Witty and helpful assistant"
+            ).ask()
+            or "Witty and helpful assistant"
+        )
+
+        tone = (
+            questionary.select(
+                "Default tone:",
+                choices=[
+                    questionary.Choice("casual - Relaxed and friendly", value="casual"),
+                    questionary.Choice("friendly - Warm and approachable", value="friendly"),
+                    questionary.Choice("professional - Polite and formal", value="professional"),
+                ],
+                default="casual",
+            ).ask()
+            or "casual"
+        )
+
+        self.console.print()
+        return bot_name, personality_desc, tone
+
+    def _get_safety_config(self) -> dict:
+        """Get safety settings configuration."""
+        self.console.print("[bold]Step 4/5: Safety Settings[/bold]")
+        self.console.print()
+
+        max_replies = (
+            questionary.text(
+                "Max replies per hour:", default="30", validate=lambda x: x.isdigit() and int(x) > 0
+            ).ask()
+            or "30"
+        )
+
+        enable_quiet_hours = questionary.confirm("Enable quiet hours?", default=True).ask()
+
+        quiet_start = 0
+        quiet_end = 6
+
+        if enable_quiet_hours:
+            quiet_range = (
+                questionary.text(
+                    "Quiet hours (start-end, 24h format):",
+                    default="0-6",
+                    validate=lambda x: bool(re.match(r"^\d{1,2}-\d{1,2}$", x)),
+                ).ask()
+                or "0-6"
+            )
+
+            parts = quiet_range.split("-")
+            quiet_start = int(parts[0])
+            quiet_end = int(parts[1])
+
+        self.console.print()
+
+        return {
+            "max_replies_per_hour": int(max_replies),
+            "quiet_hours_enabled": enable_quiet_hours,
+            "quiet_hours_start": quiet_start,
+            "quiet_hours_end": quiet_end,
+        }
+
+    def _install_node_listener(self) -> bool:
+        """Install the Node.js WhatsApp listener."""
+        self.console.print("[bold]Step 5/5: Installing WhatsApp listener...[/bold]")
+        self.console.print()
+
+        installer = NodeInstaller(self.paths.node_dir)
+
+        # Check if already installed
+        if installer.is_installed():
+            self.console.print("  [green]✓[/green] Node.js listener already installed")
+            self.console.print()
+            return True
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console,
+        ) as progress:
+            task = progress.add_task("Installing...", total=None)
+
+            def update_progress(step: str, message: str):
+                progress.update(task, description=message)
+
+            success = installer.install(progress_callback=update_progress)
+
+        if success:
+            self.console.print("  [green]✓[/green] Node.js listener installed")
+        else:
+            self.console.print("  [red]✗[/red] Installation failed")
+
+        self.console.print()
+        return success
+
+    def _generate_configs(
+        self, api_key: str, bot_name: str, personality_desc: str, tone: str, safety_config: dict
+    ) -> None:
+        """Generate configuration files."""
+        # Ensure directories exist
+        self.paths.ensure_directories()
+
+        # Main config
+        config = {
+            "bot": {
+                "name": bot_name,
+            },
+            "openai": {
+                "api_key": api_key,
+                "model": "gpt-4o",
+                "max_response_tokens": 150,
+                "temperature": 0.8,
+            },
+            "personality": {
+                "base_prompt": f"You are {bot_name}, a {personality_desc}.",
+                "default_tone": tone,
+            },
+            "safety": {
+                "max_replies_per_hour": safety_config["max_replies_per_hour"],
+                "cooldown_seconds": 60,
+                "quiet_hours": {
+                    "enabled": safety_config["quiet_hours_enabled"],
+                    "start": safety_config["quiet_hours_start"],
+                    "end": safety_config["quiet_hours_end"],
+                },
+            },
+        }
+
+        with open(self.paths.config_file, "w") as f:
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+        # Contacts config (template)
+        contacts_config = {
+            "contacts": {
+                "# Add contacts here using their JID": {
+                    "name": "Example Contact",
+                    "role": "friend",
+                    "tone": "casual",
+                }
+            },
+            "defaults": {
+                "role": "unknown",
+                "tone": "neutral",
+                "allow_proactive": False,
+            },
+        }
+
+        # Remove the comment key (it was just for illustration)
+        contacts_config["contacts"] = {}
+
+        with open(self.paths.contacts_config, "w") as f:
+            yaml.dump(contacts_config, f, default_flow_style=False, sort_keys=False)
+            f.write("\n# Add contacts like this:\n")
+            f.write("# contacts:\n")
+            f.write('#   "+14155551234@s.whatsapp.net":\n')
+            f.write("#     name: John\n")
+            f.write(
+                "#     role: friend  # girlfriend, sister, friend, family, colleague, unknown\n"
+            )
+            f.write(
+                "#     tone: casual  # affectionate, loving, friendly, casual, sarcastic, neutral\n"
+            )
+
+        # Groups config (template)
+        groups_config = {
+            "groups": {},
+            "defaults": {
+                "category": "unknown",
+                "reply_policy": "selective",
+            },
+        }
+
+        with open(self.paths.groups_config, "w") as f:
+            yaml.dump(groups_config, f, default_flow_style=False, sort_keys=False)
+            f.write("\n# Add groups like this:\n")
+            f.write("# groups:\n")
+            f.write('#   "120363012345678901@g.us":\n')
+            f.write("#     name: Family Chat\n")
+            f.write("#     category: family  # family, friends, work, unknown\n")
+            f.write("#     reply_policy: always  # always, selective, never\n")
+
+        # Policies config (template)
+        policies_config = {
+            "rules": [
+                {
+                    "name": "dm_always",
+                    "conditions": {
+                        "is_dm": True,
+                    },
+                    "action": "always",
+                },
+                {
+                    "name": "group_selective",
+                    "conditions": {
+                        "is_group": True,
+                    },
+                    "action": "selective",
+                },
+            ],
+            "fallback": {
+                "action": "selective",
+            },
+        }
+
+        with open(self.paths.policies_config, "w") as f:
+            yaml.dump(policies_config, f, default_flow_style=False, sort_keys=False)
+
+        self.console.print(f"[dim]Config saved to {self.paths.config_dir}[/dim]")

wingman/config/__init__.py

@@ -0,0 +1,31 @@
+"""Configuration module for Wingman."""
+
+from .paths import WingmanPaths
+from .personality import SYSTEM_PROMPT, RoleBasedPromptBuilder, get_personality_prompt
+from .registry import (
+    ContactProfile,
+    ContactRegistry,
+    ContactRole,
+    ContactTone,
+    GroupCategory,
+    GroupConfig,
+    GroupRegistry,
+    ReplyPolicy,
+)
+from .settings import Settings
+
+__all__ = [
+    "Settings",
+    "WingmanPaths",
+    "SYSTEM_PROMPT",
+    "get_personality_prompt",
+    "RoleBasedPromptBuilder",
+    "ContactRegistry",
+    "GroupRegistry",
+    "ContactProfile",
+    "GroupConfig",
+    "ContactRole",
+    "ContactTone",
+    "GroupCategory",
+    "ReplyPolicy",
+]

wingman/config/paths.py

@@ -0,0 +1,153 @@
+"""XDG-compliant path management for Wingman."""
+
+from pathlib import Path
+
+from platformdirs import user_cache_dir, user_config_dir, user_data_dir
+
+
+class WingmanPaths:
+    """
+    Manages XDG-compliant paths for Wingman configuration and data.
+
+    Directories:
+    - config_dir: ~/.config/wingman/ - Configuration files (YAML configs)
+    - data_dir: ~/.local/share/wingman/ - Data files (DB, auth state)
+    - cache_dir: ~/.cache/wingman/ - Cache and logs
+    - node_dir: ~/.config/wingman/node_listener/ - Installed Node.js listener
+    """
+
+    APP_NAME = "wingman"
+    APP_AUTHOR = "wingman"
+
+    def __init__(
+        self,
+        config_dir: Path | None = None,
+        data_dir: Path | None = None,
+        cache_dir: Path | None = None,
+    ):
+        """
+        Initialize Wingman paths.
+
+        Args:
+            config_dir: Override config directory (default: ~/.config/wingman)
+            data_dir: Override data directory (default: ~/.local/share/wingman)
+            cache_dir: Override cache directory (default: ~/.cache/wingman)
+        """
+        self._config_dir = config_dir or Path(user_config_dir(self.APP_NAME, self.APP_AUTHOR))
+        self._data_dir = data_dir or Path(user_data_dir(self.APP_NAME, self.APP_AUTHOR))
+        self._cache_dir = cache_dir or Path(user_cache_dir(self.APP_NAME, self.APP_AUTHOR))
+
+    @property
+    def config_dir(self) -> Path:
+        """Config directory (~/.config/wingman/)."""
+        return self._config_dir
+
+    @property
+    def data_dir(self) -> Path:
+        """Data directory (~/.local/share/wingman/)."""
+        return self._data_dir
+
+    @property
+    def cache_dir(self) -> Path:
+        """Cache directory (~/.cache/wingman/)."""
+        return self._cache_dir
+
+    @property
+    def log_dir(self) -> Path:
+        """Log directory (~/.cache/wingman/logs/)."""
+        return self._cache_dir / "logs"
+
+    @property
+    def node_dir(self) -> Path:
+        """Node.js listener directory (~/.config/wingman/node_listener/)."""
+        return self._config_dir / "node_listener"
+
+    @property
+    def auth_state_dir(self) -> Path:
+        """WhatsApp auth state directory (~/.local/share/wingman/auth_state/)."""
+        return self._data_dir / "auth_state"
+
+    @property
+    def db_path(self) -> Path:
+        """Database file path (~/.local/share/wingman/conversations.db)."""
+        return self._data_dir / "conversations.db"
+
+    @property
+    def config_file(self) -> Path:
+        """Main config file (~/.config/wingman/config.yaml)."""
+        return self._config_dir / "config.yaml"
+
+    @property
+    def contacts_config(self) -> Path:
+        """Contacts config file (~/.config/wingman/contacts.yaml)."""
+        return self._config_dir / "contacts.yaml"
+
+    @property
+    def groups_config(self) -> Path:
+        """Groups config file (~/.config/wingman/groups.yaml)."""
+        return self._config_dir / "groups.yaml"
+
+    @property
+    def policies_config(self) -> Path:
+        """Policies config file (~/.config/wingman/policies.yaml)."""
+        return self._config_dir / "policies.yaml"
+
+    @property
+    def personality_config(self) -> Path:
+        """Personality config file (~/.config/wingman/personality.yaml)."""
+        return self._config_dir / "personality.yaml"
+
+    @property
+    def pid_file(self) -> Path:
+        """PID file for daemon (~/.cache/wingman/wingman.pid)."""
+        return self._cache_dir / "wingman.pid"
+
+    @property
+    def launchd_plist(self) -> Path:
+        """Launchd plist file (~/Library/LaunchAgents/com.wingman.agent.plist)."""
+        return Path.home() / "Library" / "LaunchAgents" / "com.wingman.agent.plist"
+
+    def ensure_directories(self) -> None:
+        """Create all required directories if they don't exist."""
+        for directory in [
+            self._config_dir,
+            self._data_dir,
+            self._cache_dir,
+            self.log_dir,
+            self.auth_state_dir,
+        ]:
+            directory.mkdir(parents=True, exist_ok=True)
+
+    def config_exists(self) -> bool:
+        """Check if the main config file exists."""
+        return self.config_file.exists()
+
+    def is_initialized(self) -> bool:
+        """Check if Wingman has been set up (config and node_listener exist)."""
+        return (
+            self.config_file.exists()
+            and self.node_dir.exists()
+            and (self.node_dir / "dist" / "index.js").exists()
+        )
+
+    @classmethod
+    def from_project_root(cls, project_root: Path) -> "WingmanPaths":
+        """
+        Create paths relative to a project root (for development/legacy mode).
+
+        This maintains backward compatibility with the original project structure.
+        """
+        return cls(
+            config_dir=project_root / "config",
+            data_dir=project_root / "data",
+            cache_dir=project_root / "logs",
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f"WingmanPaths(\n"
+            f"  config_dir={self._config_dir}\n"
+            f"  data_dir={self._data_dir}\n"
+            f"  cache_dir={self._cache_dir}\n"
+            f")"
+        )