quickcall-integrations 0.1.0__tar.gz

quickcall_integrations-0.1.0/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gh secret set:*)"
+    ]
+  }
+}

quickcall_integrations-0.1.0/.github/workflows/deploy-mcp.yml

@@ -0,0 +1,96 @@
+name: Deploy MCP Server
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+env:
+  MCP_IMAGE: quickcall-mcp-oss
+
+jobs:
+  build-and-deploy-mcp:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Log in to Azure Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ secrets.AZURE_CONTAINER_REGISTRY }}
+          username: ${{ secrets.AZURE_ACR_USERNAME }}
+          password: ${{ secrets.AZURE_ACR_PASSWORD }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and push MCP image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: |
+            ${{ secrets.AZURE_CONTAINER_REGISTRY }}/${{ env.MCP_IMAGE }}:latest
+            ${{ secrets.AZURE_CONTAINER_REGISTRY }}/${{ env.MCP_IMAGE }}:${{ github.sha }}
+          cache-from: type=registry,ref=${{ secrets.AZURE_CONTAINER_REGISTRY }}/${{ env.MCP_IMAGE }}:buildcache
+          cache-to: type=registry,ref=${{ secrets.AZURE_CONTAINER_REGISTRY }}/${{ env.MCP_IMAGE }}:buildcache,mode=max
+
+      - name: Azure Login
+        uses: azure/login@v1
+        with:
+          creds: ${{ secrets.AZURE_CREDENTIALS }}
+
+      - name: Configure Container Registry
+        run: |
+          az containerapp registry set \
+            --name quickcall-mcp-oss \
+            --resource-group ${{ secrets.AZURE_RESOURCE_GROUP }} \
+            --server ${{ secrets.AZURE_CONTAINER_REGISTRY }} \
+            --username ${{ secrets.AZURE_ACR_USERNAME }} \
+            --password ${{ secrets.AZURE_ACR_PASSWORD }}
+
+      - name: Deploy MCP to Azure Container Apps
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        run: |
+          az containerapp update \
+            --name quickcall-mcp-oss \
+            --resource-group ${{ secrets.AZURE_RESOURCE_GROUP }} \
+            --image ${{ secrets.AZURE_CONTAINER_REGISTRY }}/${{ env.MCP_IMAGE }}:${{ github.sha }} \
+            --min-replicas 1 \
+            --max-replicas 5 \
+            --set-env-vars \
+              MCP_TRANSPORT=streamable-http \
+              MCP_HOST=0.0.0.0 \
+              MCP_PORT=8001 \
+              OPENAI_API_KEY="$OPENAI_API_KEY"
+
+      - name: Configure External Ingress
+        run: |
+          az containerapp ingress enable \
+            --name quickcall-mcp-oss \
+            --resource-group ${{ secrets.AZURE_RESOURCE_GROUP }} \
+            --type external \
+            --target-port 8001 \
+            --transport http
+
+      - name: Get App URL
+        run: |
+          APP_URL=$(az containerapp show \
+            --name quickcall-mcp-oss \
+            --resource-group ${{ secrets.AZURE_RESOURCE_GROUP }} \
+            --query properties.configuration.ingress.fqdn -o tsv)
+
+          echo "🚀 MCP Server deployed at: https://$APP_URL"
+          echo "📊 Health check: https://$APP_URL/health"
+          echo "🔧 MCP endpoint: https://$APP_URL/mcp"
+
+      - name: Azure Logout
+        run: az logout

quickcall_integrations-0.1.0/.gitignore

@@ -0,0 +1,101 @@
+# Secrets and environment
+secrets/
+*.env
+*.env.*
+*.pem
+mcp-inspector-config.json
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Logs
+*.log
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# UV
+.uv/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Ruff
+.ruff_cache/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

quickcall_integrations-0.1.0/Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+# Copy requirements and install dependencies
+COPY requirements.txt .
+RUN uv pip install --system -r requirements.txt
+
+# Copy application code
+COPY mcp_server/ ./mcp_server/
+
+# Set Python path
+ENV PYTHONPATH=/app/mcp_server
+
+# Expose MCP port
+EXPOSE 8001
+
+# Run MCP server
+WORKDIR /app/mcp_server
+CMD ["python", "server.py"]

quickcall_integrations-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: quickcall-integrations
+Version: 0.1.0
+Summary: MCP server with developer integrations for Claude Code and Cursor
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=2.13.0
+Requires-Dist: pydantic>=2.11.7
+Description-Content-Type: text/markdown
+
+# QuickCall Integrations
+
+Developer integrations for Claude Code and Cursor.
+
+**Current integrations:**
+- Git - commits, diffs, code changes
+
+**Coming soon:**
+- Calendar
+- Slack
+- GitHub PRs & Issues
+
+## Quick Install
+
+Add to Claude Code:
+```bash
+claude mcp add quickcall -- uvx quickcall-integrations
+```
+
+Or add to your `.mcp.json`:
+```json
+{
+  "mcpServers": {
+    "quickcall": {
+      "command": "uvx",
+      "args": ["quickcall-integrations"]
+    }
+  }
+}
+```
+
+## Usage
+
+Just ask Claude:
+- "What did I work on today?"
+- "Show me recent commits"
+- "What's changed in the last week?"
+
+Or use the plugin command: `/quickcall:daily-updates`
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/quickcall-dev/quickcall-integrations
+cd quickcall-integrations
+uv pip install -e .
+
+# Run locally
+quickcall-integrations
+
+# Run with SSE (for remote deployment)
+MCP_TRANSPORT=sse quickcall-integrations
+```

quickcall_integrations-0.1.0/README.md

@@ -0,0 +1,54 @@
+# QuickCall Integrations
+
+Developer integrations for Claude Code and Cursor.
+
+**Current integrations:**
+- Git - commits, diffs, code changes
+
+**Coming soon:**
+- Calendar
+- Slack
+- GitHub PRs & Issues
+
+## Quick Install
+
+Add to Claude Code:
+```bash
+claude mcp add quickcall -- uvx quickcall-integrations
+```
+
+Or add to your `.mcp.json`:
+```json
+{
+  "mcpServers": {
+    "quickcall": {
+      "command": "uvx",
+      "args": ["quickcall-integrations"]
+    }
+  }
+}
+```
+
+## Usage
+
+Just ask Claude:
+- "What did I work on today?"
+- "Show me recent commits"
+- "What's changed in the last week?"
+
+Or use the plugin command: `/quickcall:daily-updates`
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/quickcall-dev/quickcall-integrations
+cd quickcall-integrations
+uv pip install -e .
+
+# Run locally
+quickcall-integrations
+
+# Run with SSE (for remote deployment)
+MCP_TRANSPORT=sse quickcall-integrations
+```

quickcall_integrations-0.1.0/mcp_server/__init__.py

@@ -0,0 +1,6 @@
+"""
+MCP Server for QuickCall
+GitHub integration tools for AI assistant
+"""
+
+__version__ = "0.3.4"

quickcall_integrations-0.1.0/mcp_server/config.py

@@ -0,0 +1,10 @@
+"""
+Configuration for QuickCall Integrations MCP Server.
+"""
+
+
+class Config:
+    """Configuration class for MCP server."""
+
+    SERVER_NAME: str = "QuickCall Integrations (OSS)"
+    SERVER_VERSION: str = "1.0.0"

quickcall_integrations-0.1.0/mcp_server/server.py

@@ -0,0 +1,42 @@
+"""
+QuickCall Integrations MCP Server
+
+Git tools for developers - view commits, diffs, and changes.
+"""
+
+import os
+
+from fastmcp import FastMCP
+
+from mcp_server.tools.git_tools import create_git_tools
+from mcp_server.tools.utility_tools import create_utility_tools
+
+
+def create_server() -> FastMCP:
+    """Create and configure the MCP server."""
+    mcp = FastMCP("quickcall-integrations")
+
+    create_git_tools(mcp)
+    create_utility_tools(mcp)
+
+    return mcp
+
+
+mcp = create_server()
+
+
+def main():
+    """Entry point for the CLI."""
+    transport = os.getenv("MCP_TRANSPORT", "stdio")
+
+    if transport == "stdio":
+        mcp.run(transport="stdio")
+    else:
+        host = os.getenv("MCP_HOST", "0.0.0.0")
+        port = int(os.getenv("MCP_PORT", "8001"))
+        print(f"Starting server: http://{host}:{port}/mcp (transport: {transport})")
+        mcp.run(transport=transport, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

quickcall_integrations-0.1.0/mcp_server/tools/__init__.py

@@ -0,0 +1 @@
+"""MCP tools for external integrations"""

quickcall_integrations-0.1.0/mcp_server/tools/git_tools.py

@@ -0,0 +1,194 @@
+"""
+Git Tools - Simple tools for viewing repository changes.
+"""
+
+from typing import Optional, List
+import subprocess
+
+from fastmcp import FastMCP
+from fastmcp.exceptions import ToolError
+from pydantic import Field
+
+
+def _run_git(args: List[str], cwd: Optional[str] = None) -> str:
+    """Run a git command and return output."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            raise ToolError(f"Git error: {result.stderr.strip()}")
+        return result.stdout.strip()
+    except subprocess.TimeoutExpired:
+        raise ToolError("Git command timed out")
+    except FileNotFoundError:
+        raise ToolError("Git not found")
+
+
+def _get_repo_info(cwd: Optional[str] = None) -> dict:
+    """Get repository info."""
+    try:
+        _run_git(["rev-parse", "--git-dir"], cwd)
+    except ToolError:
+        raise ToolError(f"Not a git repository: {cwd or 'current directory'}")
+
+    repo_root = _run_git(["rev-parse", "--show-toplevel"], cwd)
+
+    try:
+        remote_url = _run_git(["remote", "get-url", "origin"], cwd)
+        if "github.com" in remote_url:
+            if remote_url.startswith("git@"):
+                path = remote_url.split(":")[-1]
+            else:
+                path = remote_url.split("github.com/")[-1]
+            path = path.rstrip(".git")
+            parts = path.split("/")
+            owner, repo = (parts[0], parts[1]) if len(parts) >= 2 else (None, None)
+        else:
+            owner, repo = None, None
+    except ToolError:
+        owner, repo = None, None
+
+    try:
+        branch = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd)
+    except ToolError:
+        branch = "unknown"
+
+    return {"root": repo_root, "owner": owner, "repo": repo, "branch": branch}
+
+
+def create_git_tools(mcp: FastMCP) -> None:
+    """Add git tools to the MCP server."""
+
+    @mcp.tool(tags={"git", "updates"})
+    def get_updates(
+        path: str = Field(
+            ...,
+            description="Path to git repository. Use the user's current working directory.",
+        ),
+        days: int = Field(
+            default=7,
+            description="Number of days to look back (default: 7)",
+        ),
+        author: Optional[str] = Field(
+            default=None,
+            description="Filter by author name/email",
+        ),
+    ) -> dict:
+        """
+        Get updates from a git repository.
+
+        Returns commits, diff stats, file changes, and actual code diff for the given period.
+        """
+        try:
+            repo_info = _get_repo_info(path)
+            repo_name = f"{repo_info['owner']}/{repo_info['repo']}" if repo_info['owner'] else repo_info['root']
+
+            result = {
+                "repository": repo_name,
+                "branch": repo_info['branch'],
+                "period": f"Last {days} days",
+            }
+
+            # Get commits
+            since_date = f"{days} days ago"
+            log_format = "--pretty=format:%H|%an|%ad|%s"
+            log_args = ["log", log_format, "--date=short", f"--since={since_date}"]
+            if author:
+                log_args.extend(["--author", author])
+
+            log_output = _run_git(log_args, path)
+
+            commits = []
+            for line in log_output.split("\n"):
+                if not line:
+                    continue
+                parts = line.split("|", 3)
+                if len(parts) >= 4:
+                    commits.append({
+                        "sha": parts[0][:7],
+                        "author": parts[1],
+                        "date": parts[2],
+                        "message": parts[3],
+                    })
+
+            result["commits"] = commits
+            result["commit_count"] = len(commits)
+
+            if not commits:
+                result["diff"] = {"files_changed": 0, "additions": 0, "deletions": 0, "patch": ""}
+                return result
+
+            # Get total diff between oldest and newest commit
+            oldest_sha = commits[-1]["sha"]
+            newest_sha = commits[0]["sha"]
+
+            try:
+                # Get stats
+                numstat = _run_git(["diff", "--numstat", f"{oldest_sha}^", newest_sha], path)
+
+                files = []
+                total_add = 0
+                total_del = 0
+
+                for line in numstat.split("\n"):
+                    if not line:
+                        continue
+                    parts = line.split("\t")
+                    if len(parts) >= 3:
+                        adds = int(parts[0]) if parts[0] != "-" else 0
+                        dels = int(parts[1]) if parts[1] != "-" else 0
+                        files.append({
+                            "file": parts[2],
+                            "additions": adds,
+                            "deletions": dels,
+                        })
+                        total_add += adds
+                        total_del += dels
+
+                # Get actual diff patch
+                diff_patch = _run_git(["diff", f"{oldest_sha}^", newest_sha], path)
+
+                # Truncate if too large
+                if len(diff_patch) > 50000:
+                    diff_patch = diff_patch[:50000] + "\n\n... (truncated, diff too large)"
+
+                result["diff"] = {
+                    "files_changed": len(files),
+                    "additions": total_add,
+                    "deletions": total_del,
+                    "files": files[:30],
+                    "patch": diff_patch,
+                }
+            except ToolError:
+                result["diff"] = {"files_changed": 0, "additions": 0, "deletions": 0, "patch": ""}
+
+            # Uncommitted changes
+            staged = _run_git(["diff", "--cached", "--name-only"], path)
+            unstaged = _run_git(["diff", "--name-only"], path)
+
+            staged_list = [f for f in staged.split("\n") if f]
+            unstaged_list = [f for f in unstaged.split("\n") if f]
+
+            if staged_list or unstaged_list:
+                # Get uncommitted diff patch too
+                uncommitted_patch = _run_git(["diff", "HEAD"], path)
+                if len(uncommitted_patch) > 20000:
+                    uncommitted_patch = uncommitted_patch[:20000] + "\n\n... (truncated)"
+
+                result["uncommitted"] = {
+                    "staged": staged_list,
+                    "unstaged": unstaged_list,
+                    "patch": uncommitted_patch,
+                }
+
+            return result
+
+        except ToolError:
+            raise
+        except Exception as e:
+            raise ToolError(f"Failed to get updates: {str(e)}")

quickcall_integrations-0.1.0/mcp_server/tools/utility_tools.py

@@ -0,0 +1,115 @@
+"""
+Utility tools for common operations.
+
+Provides datetime helpers useful for constructing queries:
+- Get current datetime
+- Calculate date ranges (e.g., "last 7 days")
+- Add/subtract time from dates
+"""
+
+from datetime import datetime, timezone, timedelta
+from typing import Optional
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+
+def create_utility_tools(mcp: FastMCP) -> None:
+    """
+    Add utility tools to the MCP server.
+
+    Args:
+        mcp: FastMCP instance to add tools to
+    """
+
+    @mcp.tool(tags={"utility", "datetime"})
+    def get_current_datetime(
+        format: str = Field(
+            default="iso",
+            description="Output format: 'iso' for ISO 8601, 'unix' for Unix timestamp",
+        ),
+    ) -> dict:
+        """
+        Get the current date and time in UTC.
+
+        Returns:
+            Current datetime in the specified format
+        """
+        now = datetime.now(timezone.utc)
+
+        if format == "unix":
+            return {
+                "datetime": int(now.timestamp()),
+                "format": "Unix timestamp",
+            }
+        else:
+            return {
+                "datetime": now.isoformat().replace("+00:00", "Z"),
+                "format": "ISO 8601",
+            }
+
+    @mcp.tool(tags={"utility", "datetime"})
+    def calculate_date_range(
+        days_ago: int = Field(
+            ...,
+            description="Days ago to start. Use 7 for 'last week', 1 for 'yesterday', 0 for 'today'.",
+        ),
+    ) -> dict:
+        """
+        Calculate a date range from N days ago until now.
+
+        Use this to get the 'since' parameter for list_commits.
+
+        Common mappings:
+        - "last week" = days_ago=7
+        - "yesterday" = days_ago=1
+        - "today" = days_ago=0
+
+        Returns:
+            Dictionary with 'since' ISO datetime string
+        """
+        now = datetime.now(timezone.utc)
+
+        # Calculate start date (N days ago at midnight UTC)
+        start = now - timedelta(days=days_ago)
+        start = start.replace(hour=0, minute=0, second=0, microsecond=0)
+
+        return {
+            "since": start.isoformat().replace("+00:00", "Z"),
+            "now": now.isoformat().replace("+00:00", "Z"),
+            "days_ago": days_ago,
+        }
+
+    @mcp.tool(tags={"utility", "datetime"})
+    def calculate_date_offset(
+        days: int = Field(
+            default=0,
+            description="Number of days to add (negative to subtract)",
+        ),
+        hours: int = Field(
+            default=0,
+            description="Number of hours to add (negative to subtract)",
+        ),
+        base_date: Optional[str] = Field(
+            default=None,
+            description="Base date in ISO format. If not provided, uses current time.",
+        ),
+    ) -> dict:
+        """
+        Calculate a new date by adding/subtracting time.
+
+        Returns:
+            New datetime after applying the offset
+        """
+        if base_date:
+            base = datetime.fromisoformat(base_date.replace("Z", "+00:00"))
+        else:
+            base = datetime.now(timezone.utc)
+
+        result = base + timedelta(days=days, hours=hours)
+
+        return {
+            "datetime": result.isoformat().replace("+00:00", "Z"),
+            "base_date": base.isoformat().replace("+00:00", "Z"),
+            "offset": f"{days} days, {hours} hours",
+        }

quickcall_integrations-0.1.0/plugins/claude/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "quickcall",
+  "description": "From a developer to another fellow developer, let's get rid of quickcalls once and for all!",
+  "version": "1.0.0",
+  "author": {
+    "name": "Sagar"
+  }
+}

quickcall_integrations-0.1.0/plugins/claude/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "quickcall": {
+      "command": "uvx",
+      "args": ["quickcall-integrations"]
+    }
+  }
+}

quickcall_integrations-0.1.0/plugins/claude/commands/daily-updates.md

@@ -0,0 +1,25 @@
+---
+description: Get git updates for current repository (commits, diffs, changes)
+---
+
+# Daily Updates
+
+Get the recent git updates for the user's current working directory.
+
+## Instructions
+
+1. Use the `get_updates` tool from the quickcall MCP server
+2. Pass the current working directory as the `path` parameter
+3. Default to 1 day of history (or use the number the user specifies)
+4. Summarize the changes in a clear format:
+   - Number of commits
+   - Authors who contributed
+   - Key changes made (based on commit messages and diff)
+   - Any uncommitted changes
+
+## Output Format
+
+Provide a concise summary like:
+- "3 commits today by Alice and Bob"
+- "Main changes: Added auth flow, fixed login bug"
+- "You have 2 uncommitted files"

quickcall_integrations-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "quickcall-integrations"
+version = "0.1.0"
+description = "MCP server with developer integrations for Claude Code and Cursor"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "fastmcp>=2.13.0",
+    "pydantic>=2.11.7",
+]
+
+[project.scripts]
+quickcall-integrations = "mcp_server.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["mcp_server"]

quickcall_integrations-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+# MCP Server
+fastmcp>=2.13.0
+pydantic>=2.11.7

quickcall_integrations-0.1.0/tests/README.md

@@ -0,0 +1,80 @@
+# Testing QuickCall Integrations MCP Server
+
+## Quick Test
+
+### 1. Start the server
+
+```bash
+cd src && python server.py
+```
+
+### 2. Run the test
+
+```bash
+python tests/test_tools.py
+```
+
+## Using with Claude Code
+
+### Add to Claude Code config
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "quickcall": {
+      "command": "python",
+      "args": ["/path/to/quickcall-mcp-server/src/server.py"],
+      "env": {
+        "MCP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+Or for HTTP mode (run server separately):
+
+```json
+{
+  "mcpServers": {
+    "quickcall": {
+      "url": "http://localhost:8001/mcp"
+    }
+  }
+}
+```
+
+### Test in Claude Code
+
+Once configured, try these prompts:
+
+```
+"What have I been working on today?"
+"Show me my uncommitted changes"
+"Summarize my work this week"
+```
+
+## Using MCP Inspector
+
+```bash
+npx @modelcontextprotocol/inspector
+```
+
+Then connect to `http://localhost:8001/mcp` and test the tools:
+- `get_updates` - Shows uncommitted + committed changes
+- `get_diff` - Shows detailed diffs
+- `summarize_updates` - AI summary (needs OPENAI_API_KEY)
+
+## Environment Variables
+
+```bash
+# Optional - for AI summaries
+export OPENAI_API_KEY=your_key
+
+# Server config (optional)
+export MCP_HOST=0.0.0.0
+export MCP_PORT=8001
+export MCP_TRANSPORT=streamable-http  # or "stdio" for Claude Code
+```

quickcall_integrations-0.1.0/tests/test_tools.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Test QuickCall Integrations MCP Server.
+
+Tests all git tools by connecting to the running server.
+No authentication required - just uses local git commands.
+
+Usage:
+    1. Start the server: cd mcp_server && python server.py
+    2. Run this test: python tests/test_tools.py
+"""
+
+import asyncio
+import json
+import os
+import httpx
+from rich.console import Console
+
+console = Console()
+
+# MCP server endpoint
+MCP_URL = "http://localhost:8001"
+
+# Test repository path (this repo)
+TEST_REPO_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def check_server():
+    """Check if server is running."""
+    try:
+        response = httpx.get(f"{MCP_URL}/mcp", timeout=2)
+        # SSE endpoint returns 200 even without proper SSE headers
+        console.print(f"[green]✅ Server is running at {MCP_URL}[/green]")
+        return True
+    except Exception:
+        pass
+
+    console.print("[red]❌ Server is not running![/red]")
+    console.print("   Start it with: cd mcp_server && python server.py")
+    return False
+
+
+async def test_with_fastmcp():
+    """Test using FastMCP client."""
+    from fastmcp import Client
+
+    console.print("\n[bold]Testing with FastMCP Client[/bold]\n")
+
+    client = Client(f"{MCP_URL}/mcp")
+
+    async with client:
+        console.print("[green]✅ Connected to MCP server[/green]\n")
+
+        # List available tools
+        console.print("[bold]Available Tools:[/bold]")
+        tools = await client.list_tools()
+        for tool in tools:
+            console.print(f"  - {tool.name}: {tool.description[:60]}...")
+
+        console.print("\n" + "=" * 60 + "\n")
+
+        # Test 1: get_updates
+        console.print("[bold cyan]Test 1: get_updates[/bold cyan]")
+        console.print(f"Testing on repo: {TEST_REPO_PATH}\n")
+
+        try:
+            result = await client.call_tool("get_updates", {
+                "path": TEST_REPO_PATH,
+                "days": 7
+            })
+
+            if isinstance(result, list) and len(result) > 0:
+                data = json.loads(result[0].text)
+                console.print(f"[green]✅ Repository: {data['repository']}[/green]")
+                console.print(f"   Branch: {data['branch']}")
+                console.print(f"   Period: {data['period']}")
+                console.print(f"   Commits: {data['commit_count']}")
+
+                if data.get('diff'):
+                    diff = data['diff']
+                    console.print(f"   Files changed: {diff['files_changed']}")
+                    console.print(f"   Additions: +{diff['additions']}")
+                    console.print(f"   Deletions: -{diff['deletions']}")
+
+                    if diff.get('patch'):
+                        lines = diff['patch'].split('\n')[:10]
+                        console.print("\n   Diff preview:")
+                        for line in lines:
+                            if line.startswith('+') and not line.startswith('+++'):
+                                console.print(f"   [green]{line[:80]}[/green]")
+                            elif line.startswith('-') and not line.startswith('---'):
+                                console.print(f"   [red]{line[:80]}[/red]")
+                            else:
+                                console.print(f"   {line[:80]}")
+
+                if data.get('uncommitted'):
+                    uncommitted = data['uncommitted']
+                    console.print(f"\n   Uncommitted - Staged: {len(uncommitted.get('staged', []))}")
+                    console.print(f"   Uncommitted - Unstaged: {len(uncommitted.get('unstaged', []))}")
+
+                if data.get('commits'):
+                    console.print("\n   Recent commits:")
+                    for commit in data['commits'][:3]:
+                        msg = commit['message'][:50] + "..." if len(commit['message']) > 50 else commit['message']
+                        console.print(f"   - {commit['sha']} {msg}")
+
+        except Exception as e:
+            console.print(f"[red]❌ Error: {e}[/red]")
+
+        console.print("\n" + "=" * 60 + "\n")
+
+        # Test 2: Utility tools
+        console.print("[bold cyan]Test 2: Utility Tools[/bold cyan]")
+
+        try:
+            result = await client.call_tool("get_current_datetime", {})
+            if isinstance(result, list) and len(result) > 0:
+                data = json.loads(result[0].text)
+                console.print(f"[green]✅ Current time: {data['datetime']}[/green]")
+
+            result = await client.call_tool("calculate_date_range", {"days_ago": 7})
+            if isinstance(result, list) and len(result) > 0:
+                data = json.loads(result[0].text)
+                console.print(f"[green]✅ Last 7 days: since {data['since']}[/green]")
+
+        except Exception as e:
+            console.print(f"[red]❌ Error: {e}[/red]")
+
+        console.print("\n" + "=" * 60 + "\n")
+        console.print("[green]✅ All tests completed![/green]")
+
+
+async def main():
+    """Run tests."""
+    console.print("\n[bold]QuickCall Integrations - MCP Server Test[/bold]\n")
+
+    if not check_server():
+        return
+
+    await test_with_fastmcp()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())