quickcall-integrations 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

mcp_server/__init__.py

@@ -3,4 +3,4 @@ MCP Server for QuickCall
 GitHub integration tools for AI assistant
 """
 
-__version__ = "0.3.4"
+__version__ = "0.1.8"

mcp_server/api_clients/github_client.py

@@ -127,14 +127,36 @@ class GitHubClient:
     def health_check(self) -> bool:
         """Check if GitHub API is accessible with the token."""
         try:
-            self.gh.get_user().login
-            return True
+            # Use installation/repositories endpoint - works with GitHub App tokens
+            with httpx.Client() as client:
+                response = client.get(
+                    "https://api.github.com/installation/repositories",
+                    headers={
+                        "Authorization": f"Bearer {self.token}",
+                        "Accept": "application/vnd.github+json",
+                        "X-GitHub-Api-Version": "2022-11-28",
+                    },
+                    params={"per_page": 1},
+                )
+                return response.status_code == 200
         except Exception:
             return False
 
     def get_authenticated_user(self) -> str:
-        """Get the username of the authenticated user."""
-        return self.gh.get_user().login
+        """
+        Get the GitHub username associated with this installation.
+
+        Note: GitHub App installation tokens can't access /user endpoint.
+        We return the installation owner instead.
+        """
+        # Try to get from first repo's owner
+        try:
+            repos = self.list_repos(limit=1)
+            if repos:
+                return repos[0].owner.login
+        except Exception:
+            pass
+        return "GitHub App"  # Fallback
 
     def close(self):
         """Close GitHub API client."""

mcp_server/api_clients/slack_client.py

@@ -10,6 +10,7 @@ from typing import List, Optional, Dict, Any
 
 import httpx
 from pydantic import BaseModel
+from rapidfuzz import fuzz, process
 
 logger = logging.getLogger(__name__)
 
@@ -51,6 +52,18 @@ class SlackMessage(BaseModel):
     message: Optional[Dict[str, Any]] = None
 
 
+class SlackChannelMessage(BaseModel):
+    """Represents a message from channel history."""
+
+    ts: str  # Message timestamp (used as ID)
+    user: Optional[str] = None
+    user_name: Optional[str] = None
+    text: str
+    thread_ts: Optional[str] = None
+    reply_count: int = 0
+    has_thread: bool = False
+
+
 # ============================================================================
 # Slack Client
 # ============================================================================
@@ -62,6 +75,16 @@ class SlackClient:
 
     Provides simplified interface for Slack operations.
     Uses bot token authentication.
+
+    Note on Caching:
+        This client caches channel list and user mappings to reduce API calls.
+        Cache is per-instance and does NOT expire automatically.
+        New channels/users won't appear until:
+        - MCP server restarts (new session)
+        - New SlackClient instance is created
+
+        TODO: Add TTL-based cache invalidation if this becomes an issue.
+        See internal-docs/issues/007-slack-api-caching.md
     """
 
     BASE_URL = "https://slack.com/api"
@@ -80,6 +103,9 @@ class SlackClient:
             "Authorization": f"Bearer {bot_token}",
             "Content-Type": "application/json",
         }
+        # Caches (per-instance, cleared on new client)
+        self._channel_cache: Optional[List["SlackChannel"]] = None
+        self._user_cache: Optional[Dict[str, str]] = None
 
     async def _request(
         self,
@@ -161,7 +187,7 @@ class SlackClient:
     # ========================================================================
 
     def list_channels(
-        self, include_private: bool = True, limit: int = 200
+        self, include_private: bool = True, limit: int = 200, use_cache: bool = True
     ) -> List[SlackChannel]:
         """
         List Slack channels the bot has access to.
@@ -169,18 +195,30 @@ class SlackClient:
         Args:
             include_private: Whether to include private channels
             limit: Maximum channels to return
+            use_cache: Use cached results if available (default: True)
 
         Returns:
             List of channels
         """
+        # Return cached if available
+        if use_cache and self._channel_cache is not None:
+            return (
+                self._channel_cache[:limit]
+                if limit < len(self._channel_cache)
+                else self._channel_cache
+            )
+
         types = (
             "public_channel,private_channel" if include_private else "public_channel"
         )
 
+        # Always fetch 200 to ensure we get all channels for caching
+        fetch_limit = 200
+
         data = self._request_sync(
             "GET",
             "conversations.list",
-            params={"types": types, "limit": limit, "exclude_archived": True},
+            params={"types": types, "limit": fetch_limit, "exclude_archived": True},
         )
 
         channels = []
@@ -196,11 +234,13 @@ class SlackClient:
                 )
             )
 
-        return channels
+        # Cache the full result
+        self._channel_cache = channels
+        return channels[:limit] if limit < len(channels) else channels
 
     def _resolve_channel(self, channel: Optional[str] = None) -> str:
         """
-        Resolve channel name to channel ID.
+        Resolve channel name to channel ID with fuzzy matching.
 
         Args:
             channel: Channel name (with or without #) or channel ID
@@ -213,8 +253,8 @@ class SlackClient:
         if not channel:
             raise ValueError("No channel specified and no default channel configured")
 
-        # If it's already an ID (starts with C), return as-is
-        if channel.startswith("C"):
+        # If it's already an ID (starts with C or G for private), return as-is
+        if channel.startswith("C") or channel.startswith("G"):
             return channel
 
         # Strip # prefix if present
@@ -222,9 +262,27 @@ class SlackClient:
 
         # Look up channel by name
         channels = self.list_channels()
-        for ch in channels:
-            if ch.name.lower() == channel_name:
-                return ch.id
+        channel_names = {ch.name.lower(): ch for ch in channels}
+
+        # First try exact match
+        if channel_name in channel_names:
+            return channel_names[channel_name].id
+
+        # Use rapidfuzz for fuzzy matching
+        # token_sort_ratio handles word reordering (e.g., "dev no sleep" = "no sleep dev")
+        match = process.extractOne(
+            channel_name,
+            list(channel_names.keys()),
+            scorer=fuzz.token_sort_ratio,
+            score_cutoff=70,  # Minimum 70% match
+        )
+
+        if match:
+            matched_name, score, _ = match
+            logger.info(
+                f"Fuzzy matched '{channel}' to '{matched_name}' (score: {score})"
+            )
+            return channel_names[matched_name].id
 
         raise ValueError(f"Channel '{channel}' not found or bot is not a member")
 
@@ -304,6 +362,128 @@ class SlackClient:
             message=data.get("message"),
         )
 
+    # ========================================================================
+    # Message History
+    # ========================================================================
+
+    def get_channel_messages(
+        self,
+        channel: str,
+        oldest: Optional[str] = None,
+        latest: Optional[str] = None,
+        limit: int = 100,
+    ) -> List[SlackChannelMessage]:
+        """
+        Get messages from a channel.
+
+        Args:
+            channel: Channel name or ID
+            oldest: Unix timestamp - only messages after this time
+            latest: Unix timestamp - only messages before this time
+            limit: Maximum messages to return (default 100)
+
+        Returns:
+            List of messages (newest first)
+        """
+        channel_id = self._resolve_channel(channel)
+
+        params = {
+            "channel": channel_id,
+            "limit": limit,
+        }
+
+        if oldest:
+            params["oldest"] = oldest
+        if latest:
+            params["latest"] = latest
+
+        data = self._request_sync("GET", "conversations.history", params=params)
+
+        # Get user info for resolving names
+        user_map = self._get_user_map()
+
+        messages = []
+        for msg in data.get("messages", []):
+            # Skip non-message types (joins, leaves, etc.)
+            if msg.get("subtype") in ["channel_join", "channel_leave", "bot_add"]:
+                continue
+
+            user_id = msg.get("user")
+            messages.append(
+                SlackChannelMessage(
+                    ts=msg.get("ts", ""),
+                    user=user_id,
+                    user_name=user_map.get(user_id, user_id),
+                    text=msg.get("text", ""),
+                    thread_ts=msg.get("thread_ts"),
+                    reply_count=msg.get("reply_count", 0),
+                    has_thread=msg.get("reply_count", 0) > 0,
+                )
+            )
+
+        return messages
+
+    def get_thread_replies(
+        self,
+        channel: str,
+        thread_ts: str,
+        limit: int = 100,
+    ) -> List[SlackChannelMessage]:
+        """
+        Get replies in a thread.
+
+        Args:
+            channel: Channel name or ID
+            thread_ts: Thread parent message timestamp
+            limit: Maximum replies to return
+
+        Returns:
+            List of replies (includes parent message first)
+        """
+        channel_id = self._resolve_channel(channel)
+
+        params = {
+            "channel": channel_id,
+            "ts": thread_ts,
+            "limit": limit,
+        }
+
+        data = self._request_sync("GET", "conversations.replies", params=params)
+
+        user_map = self._get_user_map()
+
+        messages = []
+        for msg in data.get("messages", []):
+            user_id = msg.get("user")
+            messages.append(
+                SlackChannelMessage(
+                    ts=msg.get("ts", ""),
+                    user=user_id,
+                    user_name=user_map.get(user_id, user_id),
+                    text=msg.get("text", ""),
+                    thread_ts=msg.get("thread_ts"),
+                    reply_count=msg.get("reply_count", 0),
+                    has_thread=False,
+                )
+            )
+
+        return messages
+
+    def _get_user_map(self) -> Dict[str, str]:
+        """Get a mapping of user IDs to display names (cached)."""
+        # Return cached if available
+        if self._user_cache is not None:
+            return self._user_cache
+
+        try:
+            users = self.list_users(limit=500, include_bots=True)
+            self._user_cache = {
+                u.id: u.display_name or u.real_name or u.name for u in users
+            }
+            return self._user_cache
+        except Exception:
+            return {}
+
     # ========================================================================
     # User Operations
     # ========================================================================

mcp_server/resources/__init__.py

@@ -0,0 +1 @@
+"""MCP Resources for QuickCall."""

mcp_server/resources/slack_resources.py

@@ -0,0 +1,50 @@
+"""
+Slack MCP Resources - Exposes Slack data for Claude's context.
+
+Resources are automatically available in Claude's context when connected.
+"""
+
+import logging
+from fastmcp import FastMCP
+
+from mcp_server.tools.slack_tools import _get_client
+from mcp_server.auth import get_credential_store
+
+logger = logging.getLogger(__name__)
+
+
+def create_slack_resources(mcp: FastMCP) -> None:
+    """Add Slack resources to the MCP server."""
+
+    @mcp.resource("slack://channels")
+    def get_slack_channels() -> str:
+        """
+        List of Slack channels the bot has access to.
+
+        Use these channel names when reading/sending messages.
+        """
+        store = get_credential_store()
+
+        if not store.is_authenticated():
+            return "Slack not connected. Run connect_quickcall first."
+
+        creds = store.get_api_credentials()
+        if not creds or not creds.slack_connected or not creds.slack_bot_token:
+            return "Slack not connected. Connect at quickcall.dev/assistant."
+
+        try:
+            # Use shared cached client
+            client = _get_client()
+            channels = client.list_channels(include_private=True, limit=200)
+
+            # Format as readable list
+            lines = ["Available Slack Channels:", ""]
+            for ch in channels:
+                status = "member" if ch.is_member else "not member"
+                privacy = "private" if ch.is_private else "public"
+                lines.append(f"- #{ch.name} ({privacy}, {status})")
+
+            return "\n".join(lines)
+        except Exception as e:
+            logger.error(f"Failed to fetch Slack channels: {e}")
+            return f"Error fetching channels: {str(e)}"

mcp_server/server.py

@@ -23,6 +23,7 @@ from mcp_server.tools.utility_tools import create_utility_tools
 from mcp_server.tools.github_tools import create_github_tools
 from mcp_server.tools.slack_tools import create_slack_tools
 from mcp_server.tools.auth_tools import create_auth_tools
+from mcp_server.resources.slack_resources import create_slack_resources
 
 # Configure logging
 logging.basicConfig(
@@ -54,6 +55,9 @@ def create_server() -> FastMCP:
     create_github_tools(mcp)
     create_slack_tools(mcp)
 
+    # Register resources (available in Claude's context)
+    create_slack_resources(mcp)
+
     # Log current status
     if is_authenticated:
         logger.info("QuickCall: authenticated")

mcp_server/tools/auth_tools.py

@@ -320,7 +320,7 @@ def create_auth_tools(mcp: FastMCP):
             }
 
     @mcp.tool(tags={"auth", "slack", "quickcall"})
-    def connect_slack(open_browser: bool = True) -> Dict[str, Any]:
+    def connect_slack(open_browser: bool = True, force: bool = False) -> Dict[str, Any]:
         """
         Connect Slack to your QuickCall account.
 
@@ -330,6 +330,7 @@ def create_auth_tools(mcp: FastMCP):
 
         Args:
             open_browser: Automatically open the install URL in browser (default: True)
+            force: Force re-authorization even if already connected (use to get new permissions)
 
         Returns:
             Install URL and instructions
@@ -353,18 +354,20 @@ def create_auth_tools(mcp: FastMCP):
 
         try:
             with httpx.Client(timeout=30.0) as client:
+                params = {"force": "true"} if force else {}
                 response = client.get(
                     f"{QUICKCALL_API_URL}/api/cli/slack/install-url",
+                    params=params,
                     headers={"Authorization": f"Bearer {stored.device_token}"},
                 )
                 response.raise_for_status()
                 data = response.json()
 
-            if data.get("already_connected"):
+            if data.get("already_connected") and not force:
                 return {
                     "status": "already_connected",
                     "message": f"Slack is already connected (workspace: {data.get('team_name')})",
-                    "hint": "You can use Slack tools like list_channels, send_message, etc.",
+                    "hint": "Use force=True to re-authorize with updated permissions.",
                 }
 
             install_url = data.get("install_url")
@@ -409,3 +412,84 @@ def create_auth_tools(mcp: FastMCP):
                 "status": "error",
                 "message": f"Failed to connect Slack: {e}",
             }
+
+    @mcp.tool(tags={"auth", "slack", "quickcall"})
+    def reconnect_slack(open_browser: bool = True) -> Dict[str, Any]:
+        """
+        Reconnect Slack to get updated permissions.
+
+        Use this when the Slack app has new scopes/permissions that
+        require re-authorization. This forces a fresh OAuth flow
+        even if Slack is already connected.
+
+        Args:
+            open_browser: Automatically open the OAuth URL in browser (default: True)
+
+        Returns:
+            OAuth URL and instructions
+        """
+        store = get_credential_store()
+
+        if not store.is_authenticated():
+            return {
+                "status": "error",
+                "message": "Not connected to QuickCall",
+                "hint": "Run connect_quickcall first to authenticate.",
+            }
+
+        stored = store.get_stored_credentials()
+        if not stored:
+            return {
+                "status": "error",
+                "message": "No stored credentials found",
+                "hint": "Run connect_quickcall to authenticate.",
+            }
+
+        try:
+            with httpx.Client(timeout=30.0) as client:
+                # Force reconnect by passing force=true
+                response = client.get(
+                    f"{QUICKCALL_API_URL}/api/cli/slack/install-url",
+                    params={"force": "true"},
+                    headers={"Authorization": f"Bearer {stored.device_token}"},
+                )
+                response.raise_for_status()
+                data = response.json()
+
+            install_url = data.get("install_url")
+
+            if open_browser and install_url:
+                try:
+                    webbrowser.open(install_url)
+                except Exception as e:
+                    logger.warning(f"Failed to open browser: {e}")
+
+            return {
+                "status": "pending",
+                "message": "Please re-authorize Slack in your browser to get updated permissions.",
+                "install_url": install_url,
+                "instructions": [
+                    f"1. Open this URL: {install_url}",
+                    "2. Select your Slack workspace",
+                    "3. Review the NEW permissions and click 'Allow'",
+                ],
+                "hint": "This will update your Slack permissions with any new scopes.",
+            }
+
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                return {
+                    "status": "error",
+                    "message": "Session expired. Please reconnect.",
+                    "hint": "Run disconnect_quickcall then connect_quickcall again.",
+                }
+            return {
+                "status": "error",
+                "message": f"API error: {e.response.status_code}",
+            }
+        except Exception as e:
+            logger.error(f"Failed to get Slack install URL: {e}")
+            return {
+                "status": "error",
+                "message": f"Failed to reconnect Slack: {e}",
+            }

mcp_server/tools/slack_tools.py

@@ -6,6 +6,7 @@ Connect using connect_quickcall tool first.
 """
 
 from typing import Optional
+from datetime import datetime, timedelta, timezone
 import logging
 
 from fastmcp import FastMCP
@@ -17,9 +18,14 @@ from mcp_server.api_clients.slack_client import SlackClient, SlackAPIError
 
 logger = logging.getLogger(__name__)
 
+# Module-level client cache (keyed by token hash for security)
+_client_cache: Optional[tuple[str, SlackClient]] = None
+
 
 def _get_client() -> SlackClient:
-    """Get the Slack client, raising error if not configured."""
+    """Get the Slack client, raising error if not configured. Uses cached client."""
+    global _client_cache
+
     store = get_credential_store()
 
     if not store.is_authenticated():
@@ -43,8 +49,15 @@ def _get_client() -> SlackClient:
             "Try reconnecting Slack at quickcall.dev/assistant."
         )
 
-    # Create client with fresh token
-    return SlackClient(bot_token=creds.slack_bot_token)
+    # Return cached client if token matches
+    token_hash = hash(creds.slack_bot_token)
+    if _client_cache and _client_cache[0] == token_hash:
+        return _client_cache[1]
+
+    # Create new client and cache it
+    client = SlackClient(bot_token=creds.slack_bot_token)
+    _client_cache = (token_hash, client)
+    return client
 
 
 def create_slack_tools(mcp: FastMCP) -> None:
@@ -201,3 +214,146 @@ def create_slack_tools(mcp: FastMCP) -> None:
                 "connected": False,
                 "error": str(e),
             }
+
+    @mcp.tool(tags={"slack", "messages", "history"})
+    def read_slack_messages(
+        channel: str = Field(
+            ...,
+            description="Channel name (with or without #) or channel ID",
+        ),
+        days: int = Field(
+            default=1,
+            description="Number of days to look back (default: 1)",
+        ),
+        limit: int = Field(
+            default=50,
+            description="Maximum messages to return (default: 50)",
+        ),
+        include_threads: bool = Field(
+            default=True,
+            description="Automatically fetch thread replies for messages with threads (default: true)",
+        ),
+    ) -> dict:
+        """
+        Read messages from a Slack channel.
+
+        Returns messages from the specified channel within the date range.
+        Bot must be a member of the channel.
+        Requires QuickCall authentication with Slack connected.
+        """
+        try:
+            client = _get_client()
+
+            # Calculate oldest timestamp
+            oldest_dt = datetime.now(timezone.utc) - timedelta(days=days)
+            oldest_ts = str(oldest_dt.timestamp())
+
+            messages = client.get_channel_messages(
+                channel=channel,
+                oldest=oldest_ts,
+                limit=limit,
+            )
+
+            result_messages = []
+            for msg in messages:
+                msg_data = {
+                    "ts": msg.ts,
+                    "user": msg.user_name or msg.user,
+                    "text": msg.text,
+                    "has_thread": msg.has_thread,
+                    "reply_count": msg.reply_count,
+                }
+
+                # Fetch thread replies if message has a thread and include_threads is True
+                if include_threads and msg.has_thread and msg.reply_count > 0:
+                    try:
+                        thread_replies = client.get_thread_replies(
+                            channel=channel,
+                            thread_ts=msg.ts,
+                            limit=50,
+                        )
+                        # Skip first message (it's the parent) and add replies
+                        msg_data["replies"] = [
+                            {
+                                "ts": reply.ts,
+                                "user": reply.user_name or reply.user,
+                                "text": reply.text,
+                            }
+                            for reply in thread_replies
+                            if reply.ts != msg.ts  # Skip parent message
+                        ]
+                    except Exception as e:
+                        logger.warning(f"Failed to fetch thread {msg.ts}: {e}")
+                        msg_data["replies"] = []
+
+                result_messages.append(msg_data)
+
+            return {
+                "count": len(result_messages),
+                "channel": channel,
+                "days": days,
+                "messages": result_messages,
+            }
+        except ToolError:
+            raise
+        except SlackAPIError as e:
+            raise ToolError(str(e))
+        except ValueError as e:
+            raise ToolError(str(e))
+        except Exception as e:
+            raise ToolError(f"Failed to read Slack messages: {str(e)}")
+
+    @mcp.tool(tags={"slack", "messages", "threads"})
+    def read_slack_thread(
+        channel: str = Field(
+            ...,
+            description="Channel name (with or without #) or channel ID",
+        ),
+        thread_ts: str = Field(
+            ...,
+            description="Thread timestamp (ts) of the parent message",
+        ),
+        limit: int = Field(
+            default=50,
+            description="Maximum replies to return (default: 50)",
+        ),
+    ) -> dict:
+        """
+        Read replies in a Slack thread.
+
+        Returns all replies in the specified thread.
+        Use the 'ts' from read_slack_messages to get thread_ts.
+        Bot must be a member of the channel.
+        Requires QuickCall authentication with Slack connected.
+        """
+        try:
+            client = _get_client()
+
+            messages = client.get_thread_replies(
+                channel=channel,
+                thread_ts=thread_ts,
+                limit=limit,
+            )
+
+            return {
+                "count": len(messages),
+                "channel": channel,
+                "thread_ts": thread_ts,
+                "messages": [
+                    {
+                        "ts": msg.ts,
+                        "user": msg.user_name or msg.user,
+                        "text": msg.text,
+                        "is_parent": msg.ts == thread_ts,
+                    }
+                    for msg in messages
+                ],
+            }
+        except ToolError:
+            raise
+        except SlackAPIError as e:
+            raise ToolError(str(e))
+        except ValueError as e:
+            raise ToolError(str(e))
+        except Exception as e:
+            raise ToolError(f"Failed to read Slack thread: {str(e)}")

{quickcall_integrations-0.1.6.dist-info → quickcall_integrations-0.1.8.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: quickcall-integrations
-Version: 0.1.6
+Version: 0.1.8
 Summary: MCP server with developer integrations for Claude Code and Cursor
 Requires-Python: >=3.10
 Requires-Dist: fastmcp>=2.13.0
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pygithub>=2.8.1
+Requires-Dist: rapidfuzz>=3.0.0
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -34,11 +35,69 @@ Description-Content-Type: text/markdown
 
 ---
 
+## Capabilities
+
+- **Get standup updates** from git history (commits, diffs, stats)
+- **List PRs, commits, branches** from GitHub repos
+- **Read & send Slack messages** with auto thread fetching
+- **Fuzzy channel matching** - say "no sleep dev" and it finds "no-sleep-dev-channel"
+- **Summarize Slack channels** - get key discussions from last N days
+
 ## Integrations
 
-- **Git** - commits, diffs, code changes (always available)
-- **GitHub** - repos, PRs, commits, branches (requires QuickCall account)
-- **Slack** - send messages, list channels/users (requires QuickCall account)
+| Integration | Features | Auth Required |
+|-------------|----------|---------------|
+| **Git** | Commits, diffs, standup summaries | No |
+| **GitHub** | Repos, PRs, commits, branches | Yes |
+| **Slack** | Read/send messages, threads, channels | Yes |
+
+<details>
+<summary><strong>Available Tools (23)</strong></summary>
+
+### Git
+| Tool | Description |
+|------|-------------|
+| `get_updates` | Get git commits, diff stats, and uncommitted changes |
+
+### GitHub
+| Tool | Description |
+|------|-------------|
+| `list_repos` | List accessible repositories |
+| `list_prs` | List pull requests (open/closed/all) |
+| `get_pr` | Get PR details (title, description, files changed) |
+| `list_commits` | List commits with optional filters |
+| `get_commit` | Get commit details (message, stats, files) |
+| `list_branches` | List repository branches |
+| `check_github_connection` | Verify GitHub connection |
+
+### Slack
+| Tool | Description |
+|------|-------------|
+| `list_slack_channels` | List channels bot has access to |
+| `send_slack_message` | Send message to a channel |
+| `read_slack_messages` | Read messages with threads auto-fetched |
+| `read_slack_thread` | Read replies in a thread |
+| `list_slack_users` | List workspace users |
+| `check_slack_connection` | Verify Slack connection |
+| `reconnect_slack` | Re-authorize to get new permissions |
+
+### Auth
+| Tool | Description |
+|------|-------------|
+| `connect_quickcall` | Start device flow authentication |
+| `check_quickcall_status` | Check connection status |
+| `disconnect_quickcall` | Remove local credentials |
+| `connect_github` | Install GitHub App |
+| `connect_slack` | Authorize Slack App |
+
+### Utility
+| Tool | Description |
+|------|-------------|
+| `get_current_datetime` | Get current UTC datetime |
+| `calculate_date_range` | Calculate date range for queries |
+| `calculate_date_offset` | Add/subtract time from a date |
+
+</details>
 
 ## Install
 
@@ -113,14 +172,45 @@ Credentials are stored locally in `~/.quickcall/credentials.json`.
 | `/quickcall:status` | Show connection status |
 | `/quickcall:updates` | Get git updates (default: 1 day) |
 | `/quickcall:updates 7d` | Get updates for last 7 days |
+| `/quickcall:slack-summary` | Summarize Slack messages (default: 1 day) |
+| `/quickcall:slack-summary 7d` | Summarize last 7 days |
 
 ### Cursor / Other IDEs
 
-Ask the AI naturally:
-- "What did I work on today?"
-- "Show me my open PRs"
-- "List my GitHub repos"
-- "Send a message to #general on Slack"
+Ask the AI naturally - see examples below.
+
+## Example Prompts
+
+### Git
+```
+What did I work on today?
+Give me a standup summary for the last 3 days
+What changes are uncommitted?
+```
+
+### GitHub
+```
+List my repos
+Show open PRs on [repo-name]
+What commits were made this week?
+Get details of PR #123
+List branches on [repo-name]
+```
+
+### Slack
+```
+Send "Build completed" to #deployments
+What messages were posted in dev channel today?
+Read messages from no sleep dev (fuzzy matches "no-sleep-dev-channel")
+Summarize what was discussed in #engineering this week
+List channels I have access to
+```
+
+### Combined
+```
+List open PRs on [repo] and send titles to #updates channel
+What did I work on this week? Send summary to #standup
+```
 
 ## Troubleshooting
 

quickcall_integrations-0.1.8.dist-info/RECORD

@@ -0,0 +1,20 @@
+mcp_server/__init__.py,sha256=UJBr5BLG_aU2S4s2fEbRBZYd7GUWDVejxBpqezNBo8Q,98
+mcp_server/server.py,sha256=zGrrYwp7H24pJAAGAVkHDk7Y6IydOR_wo5hIL-e6_50,3001
+mcp_server/api_clients/__init__.py,sha256=kOG5_sxIVpAx_tvf1nq_P0QCkqojAVidRE-wenLS-Wc,207
+mcp_server/api_clients/github_client.py,sha256=KnF0hZ8ThBSmUVF9sgviMk5hrUe6GAgmQXY-EkOPwsM,14474
+mcp_server/api_clients/slack_client.py,sha256=w3rcGghttfYw8Ird2beNo2LEYLc3rCTbUKMH4X7QQuQ,16447
+mcp_server/auth/__init__.py,sha256=YQpDPH5itIaBuEm0AtwNCHxTX4L5dLutTximVamsItw,552
+mcp_server/auth/credentials.py,sha256=OCPs_4DcQ1zHEBgkcPDNCHVFFO36Xe6_QBx_5Jn2xgk,9379
+mcp_server/auth/device_flow.py,sha256=NXNWHzd-CA4dlhEVCgUhwfpe9TpMKpLSJuyFCh70xKs,8371
+mcp_server/resources/__init__.py,sha256=JrMa3Kf-DmeCB4GwVNfmfw9OGnxF9pJJxCw9Y7u7ujQ,35
+mcp_server/resources/slack_resources.py,sha256=b_CPxAicwkF3PsBXIat4QoLbDUHM2g_iPzgzvVpwjaw,1687
+mcp_server/tools/__init__.py,sha256=vIR2ujAaTXm2DgpTsVNz3brI4G34p-Jeg44Qe0uvWc0,405
+mcp_server/tools/auth_tools.py,sha256=yev9UZi-i842JPx_9IgGf7pWChEQzSXRiICsHo46s9Q,17853
+mcp_server/tools/git_tools.py,sha256=5cZfngkP1wHNYUvGtLFcMjS7bhrFzxAC_TPz0h3CUB0,7691
+mcp_server/tools/github_tools.py,sha256=GomR88SByAbdi4VHk1vaUNp29hwWEIY6cX1t9QoMDOU,10972
+mcp_server/tools/slack_tools.py,sha256=-HVE_x3Z1KMeYGi1xhyppEwz5ZF-I-ZD0-Up8yBeoYE,11796
+mcp_server/tools/utility_tools.py,sha256=1WiOpJivu6Ug9OLajm77lzsmFfBPgWHs8e1hNCEX_Aw,3359
+quickcall_integrations-0.1.8.dist-info/METADATA,sha256=MK4ehZKL17rzpQs5Rmun3y-KN8L5FNu8c9w-Cde06wo,6576
+quickcall_integrations-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quickcall_integrations-0.1.8.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
+quickcall_integrations-0.1.8.dist-info/RECORD,,

quickcall_integrations-0.1.6.dist-info/RECORD

@@ -1,18 +0,0 @@
-mcp_server/__init__.py,sha256=wAVZ0eHQoGovs-66UH9-kRkcv37bprVEUeinyUFS_KI,98
-mcp_server/server.py,sha256=9Ojv5DoQrCeyC6lDD3keh9BuLyNKB6mb6FUslP6z0O8,2839
-mcp_server/api_clients/__init__.py,sha256=kOG5_sxIVpAx_tvf1nq_P0QCkqojAVidRE-wenLS-Wc,207
-mcp_server/api_clients/github_client.py,sha256=Wj326ImYI11eFyItP5HQ4TD7aQ4nC6WAR12ZbneBiAQ,13569
-mcp_server/api_clients/slack_client.py,sha256=Tby3vkPo-yN38Egb6Cj7MQk6Ul3DV4BOp5nVWScR4cw,10424
-mcp_server/auth/__init__.py,sha256=YQpDPH5itIaBuEm0AtwNCHxTX4L5dLutTximVamsItw,552
-mcp_server/auth/credentials.py,sha256=OCPs_4DcQ1zHEBgkcPDNCHVFFO36Xe6_QBx_5Jn2xgk,9379
-mcp_server/auth/device_flow.py,sha256=NXNWHzd-CA4dlhEVCgUhwfpe9TpMKpLSJuyFCh70xKs,8371
-mcp_server/tools/__init__.py,sha256=vIR2ujAaTXm2DgpTsVNz3brI4G34p-Jeg44Qe0uvWc0,405
-mcp_server/tools/auth_tools.py,sha256=wuhEucxeTT08DWT1TCxoYrEa6Jy2MIpOlXBxtCeYEXQ,14586
-mcp_server/tools/git_tools.py,sha256=5cZfngkP1wHNYUvGtLFcMjS7bhrFzxAC_TPz0h3CUB0,7691
-mcp_server/tools/github_tools.py,sha256=GomR88SByAbdi4VHk1vaUNp29hwWEIY6cX1t9QoMDOU,10972
-mcp_server/tools/slack_tools.py,sha256=uXCxnzLfdi5LaM3ayVS5JT7F3MAnI6C0vB7jW0tZfjY,6303
-mcp_server/tools/utility_tools.py,sha256=1WiOpJivu6Ug9OLajm77lzsmFfBPgWHs8e1hNCEX_Aw,3359
-quickcall_integrations-0.1.6.dist-info/METADATA,sha256=rEkZ1sJXdfDJA39eANBjJcT7kAl29WmfJgJbc813--w,3780
-quickcall_integrations-0.1.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quickcall_integrations-0.1.6.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
-quickcall_integrations-0.1.6.dist-info/RECORD,,