npm - agentvibes - Versions diffs - 2.10.0 → 2.12.0 - Mend

agentvibes 2.10.0 → 2.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (437) hide show

package/docs/whatsapp-tts-standalone-plugin.md DELETED Viewed

@@ -1,628 +0,0 @@
-# WhatsApp TTS Plugin - Standalone Architecture
-## Executive Summary
-**Status**: ✅ **HIGHLY FEASIBLE - STANDALONE DESIGN**
-The WhatsApp TTS plugin should be a **completely independent repository** that depends on AgentVibes as an external library, similar to how other MCP plugins work.
-## Why Standalone?
-### Benefits of Independent Repository
-✅ **Separation of Concerns**: Plugin development doesn't affect AgentVibes core
-✅ **Independent Versioning**: Plugin can release updates without AgentVibes releases
-✅ **Easier Maintenance**: Different maintainers can own different repos
-✅ **Cleaner Dependencies**: Users only install what they need
-✅ **Community Contributions**: Easier for external contributors
-✅ **Multiple Plugins**: Opens path for Signal-TTS, Telegram-TTS, Slack-TTS, etc.
-### Dependency Model
-```
-┌─────────────────────────────────────┐
-│   whatsapp-agentvibes-plugin        │ ← New Standalone Repo
-│   (Independent MCP Server)          │
-└──────────────┬──────────────────────┘
-               │ depends on (via subprocess/API calls)
-               │
-      ┌────────┴─────────┬────────────────┐
-      ▼                  ▼                ▼
-┌────────────┐   ┌──────────────┐   ┌─────────────┐
-│ WhatsApp   │   │ AgentVibes   │   │ FastMCP     │
-│ MCP Server │   │ (installed)  │   │ (Python)    │
-└────────────┘   └──────────────┘   └─────────────┘
-```
-## Standalone Repository Structure
-### Repository Name
-`whatsapp-agentvibes` or `agentvibes-whatsapp-plugin`
-### Directory Structure
-```
-whatsapp-agentvibes/
-├── README.md                          # Installation & usage guide
-├── LICENSE                            # Apache 2.0
-├── requirements.txt                   # Python dependencies
-├── pyproject.toml                     # Package metadata
-├── setup.py                           # Installation script
-│
-├── src/
-│   └── whatsapp_agentvibes/
-│       ├── __init__.py
-│       ├── server.py                  # Main MCP server
-│       ├── monitor.py                 # WhatsApp message monitoring
-│       ├── voice_manager.py           # Voice assignment logic
-│       ├── config.py                  # Configuration management
-│       └── agentvibes_client.py       # AgentVibes integration layer
-│
-├── config/
-│   ├── notifications.json.example     # Example configuration
-│   └── claude_desktop_config.json     # MCP setup example
-│
-├── tests/
-│   ├── test_voice_assignment.py
-│   ├── test_monitor.py
-│   └── test_config.py
-│
-└── docs/
-    ├── installation.md
-    ├── configuration.md
-    ├── troubleshooting.md
-    └── development.md
-```
-## How It Integrates with AgentVibes
-### Option 1: Subprocess Calls (RECOMMENDED)
-**The plugin calls AgentVibes' play-tts.sh script directly:**
-```python
-# whatsapp_agentvibes/agentvibes_client.py
-import subprocess
-import os
-from pathlib import Path
-class AgentVibesClient:
-    """Client for calling AgentVibes TTS functionality"""
-    def __init__(self):
-        # Detect AgentVibes installation
-        self.agentvibes_path = self._find_agentvibes()
-        if not self.agentvibes_path:
-            raise RuntimeError("AgentVibes not found. Please install AgentVibes first.")
-        self.play_tts_script = self.agentvibes_path / ".claude" / "hooks" / "play-tts.sh"
-    def _find_agentvibes(self) -> Path:
-        """Find AgentVibes installation"""
-        # Check common installation locations
-        locations = [
-            Path.home() / ".claude",  # Global installation
-            Path.home() / "AgentVibes" / ".claude",  # Local clone
-            Path("/usr/local/lib/agentvibes/.claude"),  # System install
-        ]
-        for location in locations:
-            if (location / "hooks" / "play-tts.sh").exists():
-                return location.parent
-        # Check if in PATH (npx installation)
-        try:
-            result = subprocess.run(
-                ["which", "agentvibes"],
-                capture_output=True,
-                text=True
-            )
-            if result.returncode == 0:
-                # Found in PATH, use global .claude
-                return Path.home()
-        except:
-            pass
-        return None
-    async def speak(self, text: str, voice: str = None, personality: str = None):
-        """Use AgentVibes to speak text"""
-        args = ["bash", str(self.play_tts_script), text]
-        if voice:
-            args.append(voice)
-        # Set environment for voice/personality
-        env = os.environ.copy()
-        if personality:
-            # Temporarily set personality via environment
-            env["TTS_PERSONALITY"] = personality
-        process = await asyncio.create_subprocess_exec(
-            *args,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            env=env
-        )
-        stdout, stderr = await process.communicate()
-        if process.returncode != 0:
-            raise RuntimeError(f"TTS failed: {stderr.decode()}")
-        return stdout.decode()
-    def list_voices(self) -> list:
-        """Get available voices from AgentVibes"""
-        voice_manager = self.agentvibes_path / ".claude" / "hooks" / "voice-manager.sh"
-        result = subprocess.run(
-            ["bash", str(voice_manager), "list-simple"],
-            capture_output=True,
-            text=True
-        )
-        if result.returncode == 0:
-            return [v.strip() for v in result.stdout.strip().split("\n") if v]
-        return []
-```
-**Pros**:
-- ✅ Simple, no modifications to AgentVibes needed
-- ✅ Uses AgentVibes exactly as installed
-- ✅ Works with any AgentVibes version
-- ✅ No API versioning issues
-**Cons**:
-- ⚠️ Requires AgentVibes to be installed and in PATH
-- ⚠️ Subprocess overhead (minimal)
-### Option 2: Python API (Future Enhancement)
-If AgentVibes later exposes a Python API:
-```python
-from agentvibes import TTS
-tts = TTS()
-tts.speak("Hello world", voice="Aria")
-```
-This would require AgentVibes to publish as a pip package.
-## Installation Process
-### Prerequisites Check
-```bash
-# Installation script checks dependencies
-#!/bin/bash
-echo "Checking prerequisites..."
-# 1. Check WhatsApp MCP Server
-if [ ! -d "$HOME/whatsapp-mcp" ]; then
-    echo "❌ WhatsApp MCP Server not found"
-    echo "   Install from: https://github.com/lharries/whatsapp-mcp"
-    exit 1
-fi
-# 2. Check AgentVibes
-if ! command -v agentvibes &> /dev/null; then
-    if [ ! -f "$HOME/.claude/hooks/play-tts.sh" ]; then
-        echo "❌ AgentVibes not found"
-        echo "   Install with: npx agentvibes install --yes"
-        exit 1
-    fi
-fi
-# 3. Check Python 3.8+
-if ! command -v python3 &> /dev/null; then
-    echo "❌ Python 3.8+ required"
-    exit 1
-fi
-echo "✅ All prerequisites met!"
-```
-### User Installation Steps
-**Step 1: Install Prerequisites**
-```bash
-# Install WhatsApp MCP Server
-git clone https://github.com/lharries/whatsapp-mcp.git
-cd whatsapp-mcp/whatsapp-bridge && go run main.go
-# Install AgentVibes
-npx agentvibes install --yes
-```
-**Step 2: Install Plugin**
-```bash
-# Option A: Via pip (if published)
-pip install whatsapp-agentvibes
-# Option B: From source
-git clone https://github.com/yourusername/whatsapp-agentvibes.git
-cd whatsapp-agentvibes
-pip install -e .
-```
-**Step 3: Configure Claude Desktop**
-```json
-{
-  "mcpServers": {
-    "whatsapp": {
-      "command": "uv",
-      "args": [
-        "--directory",
-        "/path/to/whatsapp-mcp/whatsapp-mcp-server",
-        "run",
-        "main.py"
-      ]
-    },
-    "whatsapp-agentvibes": {
-      "command": "python",
-      "args": ["-m", "whatsapp_agentvibes.server"]
-    }
-  }
-}
-```
-## Configuration File
-**Location**: `~/.config/whatsapp-agentvibes/config.json`
-```json
-{
-  "version": "1.0",
-  "whatsapp": {
-    "database_path": "~/whatsapp-mcp/whatsapp-bridge/store/messages.db",
-    "poll_interval_seconds": 2
-  },
-  "agentvibes": {
-    "installation_path": "~/.claude",
-    "default_voice": "Aria",
-    "use_personality": true
-  },
-  "notifications": {
-    "enabled_contacts": [],
-    "contact_voices": {},
-    "announce_sender_name": true,
-    "announce_media": true
-  },
-  "voice_assignment": {
-    "strategy": "hash",
-    "available_voices": []
-  }
-}
-```
-## MCP Server Implementation
-### Main Server (Standalone)
-```python
-# src/whatsapp_agentvibes/server.py
-from mcp.server import Server
-from mcp.types import Tool, TextContent
-import mcp.server.stdio
-from .monitor import WhatsAppMonitor
-from .voice_manager import VoiceManager
-from .config import Config
-from .agentvibes_client import AgentVibesClient
-class WhatsAppAgentVibesServer:
-    def __init__(self):
-        self.config = Config.load()
-        self.agentvibes = AgentVibesClient()
-        self.voice_manager = VoiceManager(self.agentvibes, self.config)
-        self.monitor = WhatsAppMonitor(
-            self.config,
-            self.voice_manager,
-            self.agentvibes
-        )
-    async def start_monitoring(self):
-        """Start monitoring WhatsApp messages"""
-        await self.monitor.start()
-# Create MCP server
-app = Server("whatsapp-agentvibes")
-wa_server = WhatsAppAgentVibesServer()
-@app.list_tools()
-async def list_tools() -> list[Tool]:
-    return [
-        Tool(
-            name="whatsapp_enable_notifications",
-            description="Enable TTS notifications for a WhatsApp contact or group",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "contact": {
-                        "type": "string",
-                        "description": "Contact name, phone number, or JID"
-                    }
-                },
-                "required": ["contact"]
-            }
-        ),
-        # ... other tools
-    ]
-@app.call_tool()
-async def call_tool(name: str, arguments: dict) -> list[TextContent]:
-    if name == "whatsapp_enable_notifications":
-        result = await wa_server.enable_notifications(arguments["contact"])
-        return [TextContent(type="text", text=result)]
-    # ... handle other tools
-async def main():
-    # Start background message monitoring
-    asyncio.create_task(wa_server.start_monitoring())
-    # Start MCP server
-    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-        await app.run(read_stream, write_stream, app.create_initialization_options())
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-## Package Metadata
-### pyproject.toml
-```toml
-[project]
-name = "whatsapp-agentvibes"
-version = "1.0.0"
-description = "WhatsApp TTS notifications plugin for AgentVibes"
-authors = [
-    {name = "Your Name", email = "your.email@example.com"}
-]
-license = {text = "Apache-2.0"}
-readme = "README.md"
-requires-python = ">=3.8"
-dependencies = [
-    "mcp>=0.9.0",
-    "aiosqlite>=0.19.0",
-]
-[project.urls]
-Homepage = "https://github.com/yourusername/whatsapp-agentvibes"
-Documentation = "https://github.com/yourusername/whatsapp-agentvibes/blob/main/docs"
-Repository = "https://github.com/yourusername/whatsapp-agentvibes"
-Issues = "https://github.com/yourusername/whatsapp-agentvibes/issues"
-[project.optional-dependencies]
-dev = [
-    "pytest>=7.0.0",
-    "pytest-asyncio>=0.21.0",
-    "black>=23.0.0",
-    "ruff>=0.1.0",
-]
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-[project.scripts]
-whatsapp-agentvibes = "whatsapp_agentvibes.server:main"
-```
-### requirements.txt
-```txt
-mcp>=0.9.0
-aiosqlite>=0.19.0
-```
-**Note**: AgentVibes is NOT listed as a dependency because it's called via subprocess, not imported.
-## README Structure
-```markdown
-# WhatsApp AgentVibes Plugin
-Voice notifications for WhatsApp messages using AgentVibes TTS.
-## Features
-- 🔔 TTS notifications for selected contacts/groups
-- 🎭 Round-robin voice assignment (different voice per contact)
-- 🗣️ Group chat speaker differentiation
-- 🎤 27+ voices via AgentVibes
-- 🌍 Multi-language support
-## Prerequisites
-1. **WhatsApp MCP Server**: https://github.com/lharries/whatsapp-mcp
-2. **AgentVibes**: `npx agentvibes install --yes`
-3. **Python 3.8+**
-## Installation
-### Quick Start
-```bash
-pip install whatsapp-agentvibes
-```
-### Configure Claude Desktop
-Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
-```json
-{
-  "mcpServers": {
-    "whatsapp-agentvibes": {
-      "command": "python",
-      "args": ["-m", "whatsapp_agentvibes.server"]
-    }
-  }
-}
-```
-## Usage
-### Enable notifications for a contact
-```
-You: "Enable WhatsApp notifications for Mom"
-Claude: ✅ Enabled notifications for Jane Smith with voice "Aria"
-```
-### View active notifications
-```
-You: "Show WhatsApp notification channels"
-Claude: 🔔 Active: Mom (Aria), Dad (Terry), Work Group (multiple)
-```
-## Configuration
-Edit `~/.config/whatsapp-agentvibes/config.json`
-## Documentation
-- [Installation Guide](docs/installation.md)
-- [Configuration Reference](docs/configuration.md)
-- [Troubleshooting](docs/troubleshooting.md)
-## License
-Apache 2.0
-```
-## Advantages of Standalone Architecture
-### 1. **Clean Separation**
-- AgentVibes = TTS engine
-- WhatsApp MCP = Message source
-- This plugin = Integration layer
-### 2. **Independent Development**
-```
-AgentVibes v2.3.0 → v2.4.0 (new voices added)
-   ↓ (plugin automatically gets new voices)
-Plugin v1.0.0 (no changes needed)
-```
-### 3. **Multiple Plugins Possible**
-```
-agentvibes-whatsapp-plugin
-agentvibes-signal-plugin
-agentvibes-telegram-plugin
-agentvibes-slack-plugin
-agentvibes-discord-plugin
-```
-All use the same AgentVibes installation!
-### 4. **Easier Testing**
-```bash
-# Test plugin without affecting AgentVibes
-cd whatsapp-agentvibes
-pytest tests/
-# Test AgentVibes without affecting plugins
-cd AgentVibes
-npm test
-```
-### 5. **User Choice**
-Users can:
-- Use AgentVibes alone (just TTS)
-- Use WhatsApp MCP alone (no voice)
-- Install plugin to combine both
-- Install multiple messaging plugins
-## Integration Testing
-### Test Script
-```python
-# tests/test_integration.py
-import pytest
-from whatsapp_agentvibes.agentvibes_client import AgentVibesClient
-def test_agentvibes_found():
-    """Test that AgentVibes is installed and accessible"""
-    client = AgentVibesClient()
-    assert client.agentvibes_path is not None
-    assert client.play_tts_script.exists()
-def test_list_voices():
-    """Test retrieving voices from AgentVibes"""
-    client = AgentVibesClient()
-    voices = client.list_voices()
-    assert len(voices) > 0
-    assert "Aria" in voices or "en_US-lessac-medium" in voices
-@pytest.mark.asyncio
-async def test_speak():
-    """Test TTS functionality"""
-    client = AgentVibesClient()
-    result = await client.speak("Test message", voice="Aria")
-    assert "Saved to:" in result or "Spoke:" in result
-```
-## Distribution Strategy
-### Phase 1: GitHub Only
-```bash
-pip install git+https://github.com/yourusername/whatsapp-agentvibes.git
-```
-### Phase 2: PyPI Publication
-```bash
-pip install whatsapp-agentvibes
-```
-### Phase 3: NPX Wrapper (Optional)
-```bash
-npx whatsapp-agentvibes install
-```
-## Documentation as Separate Repo
-The plugin repository should have comprehensive docs:
-```
-docs/
-├── installation.md           # Step-by-step setup
-├── configuration.md          # All config options
-├── usage.md                  # Example commands
-├── troubleshooting.md        # Common issues
-├── development.md            # Contributing guide
-└── architecture.md           # How it works
-```
-## Conclusion
-**Recommendation**: Build as **completely standalone plugin**
-### Key Benefits:
-✅ Independent development cycles
-✅ Easier maintenance and contributions
-✅ No coupling to AgentVibes codebase
-✅ Opens path for more messaging plugins
-✅ Users install only what they need
-✅ Cleaner architecture overall
-### Implementation:
-- New repo: `whatsapp-agentvibes` or `agentvibes-whatsapp-plugin`
-- Dependency: Calls AgentVibes via subprocess (no code imports)
-- Distribution: pip package on PyPI
-- Configuration: Separate config file
-- Testing: Independent test suite
-This is the **right architectural approach** for a plugin ecosystem! 🎉
----
-**Next Steps**:
-1. Create new standalone repository
-2. Implement AgentVibesClient wrapper
-3. Build MCP server with monitoring
-4. Write comprehensive documentation
-5. Publish to PyPI
-**Document Version**: 2.0 (Standalone Architecture)
-**Date**: 2025-11-12

package/github-profile-draft.md DELETED Viewed

@@ -1,57 +0,0 @@
-# GitHub Profile Draft - Paul Preibisch
-## Overview
-Hi! I'm Paul Preibisch, a Software Developer with over 12 years of experience, primarily in educational software. I'm currently deep diving into agentic programming and modern AI-driven development workflows.
-## Current Focus
-### 🎭 AgentVibes - Voice-Enabled AI Development
-Creator and maintainer of [AgentVibes](https://github.com/paulpreibisch/AgentVibes) (13 ⭐), an innovative tool that brings Claude Code sessions to life with voice. This project represents my deep dive into agentic programming, where I've invested over 850 hours exploring autonomous systems and AI-driven development workflows.
-**Key Features:**
-- Multi-provider TTS integration (ElevenLabs, Piper, OpenAI)
-- Dynamic personality system for voice responses
-- Language learning mode with dual-language support
-- Claude Code hook integration for seamless AI interaction
-## Recent Work
-### Educational Content Creation Platform
-Developed a highly scalable content creation tool that enables clients to upload thousands of sentences and automatically generate corresponding images for each sentence. Built with Express.js, React, and Node.js, featuring:
-- Efficient batch processing and queue management
-- Handling thousands of simultaneous content generation requests
-- Large-scale content processing workflows
-### Open Source Contributions
-- Consistent contributor to the MCP Shrimp Task Manager repository
-- Focus on task automation and workflow optimization
-- Active engagement in agent-based programming paradigms
-## Professional Experience
-### Lead Developer - CurrentSCM @ Vista Projects Limited
-- Built and maintained robust API with 850+ unique endpoints on multi-tenant enterprise application
-- Full-spectrum Laravel Framework development: notifications, queues, jobs, middleware, validations, workflows, pipelines, caching
-- Created comprehensive Test Platform for 15 Excel Import Templates using DTOs
-- Developed scalable PDF authoring microservice using TDD and SOLID principles
-- Consolidated documentation across 9 different exports, saving significant development time
-- Enhanced invoicing for milestone payments, solving complex floating point challenges
-- Completed 1800+ developer hours of support, resolving GitHub issues and features
-- Completed 33 LaraCast lessons for continuous skill development
-### Lead Developer - Movie English Project (now Globify.com)
-10 years leading platform development in educational software space
-## Tech Stack
-- **Primary:** Laravel, PHP
-- **Frontend:** React, modern JavaScript frameworks
-- **Backend:** Node.js, Express.js
-- **Current Focus:** Agentic Programming, AI Development, Claude Code
-- **DevOps:** Queue systems, batch processing, microservices
-## Get in Touch
-🌐 Website: [preibisch.biz](https://preibisch.biz)
-📍 Location: La Paz, BCS
----
-*"Digging Deep into Agentic Programming"*