quickcall-integrations 0.1.0__py3-none-any.whl

mcp_server/__init__.py

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

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"

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()

mcp_server/tools/__init__.py

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

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)}")

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+mcp_server/__init__.py,sha256=wAVZ0eHQoGovs-66UH9-kRkcv37bprVEUeinyUFS_KI,98
+mcp_server/config.py,sha256=ZvvON2pHa7eYvGjP6-SMdm-pkr3-umvtLCtZcV4WnVQ,212
+mcp_server/server.py,sha256=EWrhqcAKrbauscgnaa7kwh7l6ReflLl2Quv0GDiWtgI,945
+mcp_server/tools/__init__.py,sha256=Vqy1qzTxdt90tWFN9ZLEhTCX8aIHFB8TmMR_z70qLtE,42
+mcp_server/tools/git_tools.py,sha256=cj7Y70c0PTIEFGW_XqBAsoA4V2x12IykmPyEq3cceR8,6686
+mcp_server/tools/utility_tools.py,sha256=1WiOpJivu6Ug9OLajm77lzsmFfBPgWHs8e1hNCEX_Aw,3359
+quickcall_integrations-0.1.0.dist-info/METADATA,sha256=Yal1egxxsPVR0A4xekzOeHMsPSCBpR_2fg4V0AKc5Dw,1189
+quickcall_integrations-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quickcall_integrations-0.1.0.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
+quickcall_integrations-0.1.0.dist-info/RECORD,,

quickcall_integrations-0.1.0.dist-info/WHEEL

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

quickcall_integrations-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+quickcall-integrations = mcp_server.server:main