quickcall-integrations 0.3.9__py3-none-any.whl → 0.4.0__py3-none-any.whl

mcp_server/api_clients/github_client.py

@@ -1155,3 +1155,906 @@ class GitHubClient:
             logger.warning(f"Failed to fetch {len(errors)} PRs: {errors[:5]}...")
 
         return results
+
+    # ========================================================================
+    # Project Operations (GitHub Projects V2 via GraphQL)
+    # ========================================================================
+
+    def _graphql_request(self, query: str, variables: Optional[Dict] = None) -> Dict:
+        """
+        Execute a GraphQL request against GitHub's API.
+
+        Args:
+            query: GraphQL query or mutation string
+            variables: Optional variables for the query
+
+        Returns:
+            Response data dict
+
+        Raises:
+            GithubException: If the request fails
+        """
+        try:
+            with httpx.Client() as client:
+                response = client.post(
+                    "https://api.github.com/graphql",
+                    headers={
+                        "Authorization": f"Bearer {self.token}",
+                        "Accept": "application/vnd.github+json",
+                    },
+                    json={"query": query, "variables": variables or {}},
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                if "errors" in data:
+                    error_messages = [e.get("message", str(e)) for e in data["errors"]]
+                    raise GithubException(
+                        400, {"message": "; ".join(error_messages)}, "GraphQL Error"
+                    )
+
+                return data.get("data", {})
+        except httpx.HTTPStatusError as e:
+            logger.error(f"GraphQL request failed: HTTP {e.response.status_code}")
+            raise GithubException(e.response.status_code, e.response.json())
+        except GithubException:
+            raise
+        except Exception as e:
+            logger.error(f"GraphQL request failed: {e}")
+            raise GithubException(500, {"message": str(e)})
+
+    def list_projects(
+        self,
+        owner: Optional[str] = None,
+        is_org: bool = True,
+        limit: int = 20,
+    ) -> List[Dict[str, Any]]:
+        """
+        List GitHub Projects V2 for an organization or user.
+
+        Args:
+            owner: Organization or user name. Uses default_owner if not specified.
+            is_org: If True, treat owner as organization. If False, treat as user.
+            limit: Maximum projects to return (default: 20)
+
+        Returns:
+            List of project dicts with id, number, title, url, closed
+        """
+        owner = owner or self.default_owner
+        if not owner:
+            raise ValueError("Owner must be specified for listing projects")
+
+        if is_org:
+            query = """
+            query($owner: String!, $limit: Int!) {
+                organization(login: $owner) {
+                    projectsV2(first: $limit, orderBy: {field: UPDATED_AT, direction: DESC}) {
+                        nodes {
+                            id
+                            number
+                            title
+                            url
+                            closed
+                        }
+                    }
+                }
+            }
+            """
+            data = self._graphql_request(query, {"owner": owner, "limit": limit})
+            org = data.get("organization")
+            if not org:
+                # Try as user if org lookup fails
+                return self.list_projects(owner=owner, is_org=False, limit=limit)
+            nodes = org.get("projectsV2", {}).get("nodes", [])
+        else:
+            query = """
+            query($owner: String!, $limit: Int!) {
+                user(login: $owner) {
+                    projectsV2(first: $limit, orderBy: {field: UPDATED_AT, direction: DESC}) {
+                        nodes {
+                            id
+                            number
+                            title
+                            url
+                            closed
+                        }
+                    }
+                }
+            }
+            """
+            data = self._graphql_request(query, {"owner": owner, "limit": limit})
+            user = data.get("user")
+            if not user:
+                return []
+            nodes = user.get("projectsV2", {}).get("nodes", [])
+
+        return [
+            {
+                "id": node["id"],
+                "number": node["number"],
+                "title": node["title"],
+                "url": node["url"],
+                "closed": node["closed"],
+            }
+            for node in nodes
+            if node  # Filter out None nodes
+        ]
+
+    def get_project_id(
+        self,
+        project: str,
+        owner: Optional[str] = None,
+        is_org: bool = True,
+    ) -> Optional[str]:
+        """
+        Get the node ID of a project by number or title.
+
+        Args:
+            project: Project number (as string) or title
+            owner: Organization or user name
+            is_org: If True, treat owner as organization
+
+        Returns:
+            Project node ID or None if not found
+        """
+        owner = owner or self.default_owner
+        if not owner:
+            raise ValueError("Owner must be specified")
+
+        # If project is a number, query directly
+        if project.isdigit():
+            project_number = int(project)
+            if is_org:
+                query = """
+                query($owner: String!, $number: Int!) {
+                    organization(login: $owner) {
+                        projectV2(number: $number) {
+                            id
+                        }
+                    }
+                }
+                """
+                try:
+                    data = self._graphql_request(
+                        query, {"owner": owner, "number": project_number}
+                    )
+                except GithubException as e:
+                    # Project not found - try as user or return None
+                    if "Could not resolve" in str(e.data.get("message", "")):
+                        return self.get_project_id(
+                            project=project, owner=owner, is_org=False
+                        )
+                    raise
+                org = data.get("organization")
+                if not org:
+                    # Try as user
+                    return self.get_project_id(
+                        project=project, owner=owner, is_org=False
+                    )
+                project_data = org.get("projectV2")
+                return project_data["id"] if project_data else None
+            else:
+                query = """
+                query($owner: String!, $number: Int!) {
+                    user(login: $owner) {
+                        projectV2(number: $number) {
+                            id
+                        }
+                    }
+                }
+                """
+                try:
+                    data = self._graphql_request(
+                        query, {"owner": owner, "number": project_number}
+                    )
+                except GithubException as e:
+                    # Project not found
+                    if "Could not resolve" in str(e.data.get("message", "")):
+                        return None
+                    raise
+                user = data.get("user")
+                if not user:
+                    return None
+                project_data = user.get("projectV2")
+                return project_data["id"] if project_data else None
+
+        # Project is a title - search through list
+        projects = self.list_projects(owner=owner, is_org=is_org, limit=50)
+        for p in projects:
+            if p["title"].lower() == project.lower():
+                return p["id"]
+
+        return None
+
+    def get_issue_node_id(
+        self,
+        issue_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> str:
+        """
+        Get the node ID of an issue (required for GraphQL mutations).
+
+        Args:
+            issue_number: Issue number
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Issue node ID
+        """
+        owner = owner or self.default_owner
+        repo = repo or self.default_repo
+        if not owner or not repo:
+            raise ValueError("Repository owner and name must be specified")
+
+        query = """
+        query($owner: String!, $repo: String!, $number: Int!) {
+            repository(owner: $owner, name: $repo) {
+                issue(number: $number) {
+                    id
+                }
+            }
+        }
+        """
+        data = self._graphql_request(
+            query, {"owner": owner, "repo": repo, "number": issue_number}
+        )
+        repository = data.get("repository")
+        if not repository:
+            raise GithubException(
+                404, {"message": f"Repository {owner}/{repo} not found"}
+            )
+        issue = repository.get("issue")
+        if not issue:
+            raise GithubException(404, {"message": f"Issue #{issue_number} not found"})
+        return issue["id"]
+
+    def add_issue_to_project(
+        self,
+        issue_number: int,
+        project: str,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+        project_owner: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Add an issue to a GitHub Project V2.
+
+        Args:
+            issue_number: Issue number to add
+            project: Project number (as string) or title
+            owner: Repository owner (for the issue)
+            repo: Repository name
+            project_owner: Owner of the project (org or user). Defaults to repo owner.
+
+        Returns:
+            Dict with project_item_id and success status
+        """
+        owner = owner or self.default_owner
+        repo = repo or self.default_repo
+        project_owner = project_owner or owner
+
+        if not owner or not repo:
+            raise ValueError("Repository owner and name must be specified")
+
+        # Get issue node ID
+        issue_node_id = self.get_issue_node_id(issue_number, owner=owner, repo=repo)
+
+        # Get project node ID
+        project_id = self.get_project_id(project, owner=project_owner, is_org=True)
+        if not project_id:
+            raise GithubException(
+                404, {"message": f"Project '{project}' not found for {project_owner}"}
+            )
+
+        # Add to project using mutation
+        mutation = """
+        mutation($projectId: ID!, $contentId: ID!) {
+            addProjectV2ItemById(input: {projectId: $projectId, contentId: $contentId}) {
+                item {
+                    id
+                }
+            }
+        }
+        """
+        data = self._graphql_request(
+            mutation, {"projectId": project_id, "contentId": issue_node_id}
+        )
+
+        item = data.get("addProjectV2ItemById", {}).get("item")
+        return {
+            "success": True,
+            "issue_number": issue_number,
+            "project": project,
+            "project_item_id": item["id"] if item else None,
+        }
+
+    def remove_issue_from_project(
+        self,
+        issue_number: int,
+        project: str,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+        project_owner: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Remove an issue from a GitHub Project V2.
+
+        Args:
+            issue_number: Issue number to remove
+            project: Project number (as string) or title
+            owner: Repository owner (for the issue)
+            repo: Repository name
+            project_owner: Owner of the project (org or user). Defaults to repo owner.
+
+        Returns:
+            Dict with success status
+        """
+        owner = owner or self.default_owner
+        repo = repo or self.default_repo
+        project_owner = project_owner or owner
+
+        if not owner or not repo:
+            raise ValueError("Repository owner and name must be specified")
+
+        # Get project node ID
+        project_id = self.get_project_id(project, owner=project_owner, is_org=True)
+        if not project_id:
+            raise GithubException(
+                404, {"message": f"Project '{project}' not found for {project_owner}"}
+            )
+
+        # Get issue node ID
+        issue_node_id = self.get_issue_node_id(issue_number, owner=owner, repo=repo)
+
+        # First, find the project item ID for this issue
+        query = """
+        query($projectId: ID!, $cursor: String) {
+            node(id: $projectId) {
+                ... on ProjectV2 {
+                    items(first: 100, after: $cursor) {
+                        nodes {
+                            id
+                            content {
+                                ... on Issue {
+                                    id
+                                    number
+                                }
+                            }
+                        }
+                        pageInfo {
+                            hasNextPage
+                            endCursor
+                        }
+                    }
+                }
+            }
+        }
+        """
+
+        # Paginate to find the item
+        cursor = None
+        item_id = None
+        while True:
+            data = self._graphql_request(
+                query, {"projectId": project_id, "cursor": cursor}
+            )
+            node = data.get("node", {})
+            items = node.get("items", {})
+
+            for item in items.get("nodes", []):
+                content = item.get("content")
+                if content and content.get("id") == issue_node_id:
+                    item_id = item["id"]
+                    break
+
+            if item_id:
+                break
+
+            page_info = items.get("pageInfo", {})
+            if not page_info.get("hasNextPage"):
+                break
+            cursor = page_info.get("endCursor")
+
+        if not item_id:
+            raise GithubException(
+                404,
+                {"message": f"Issue #{issue_number} not found in project '{project}'"},
+            )
+
+        # Delete the item from project
+        mutation = """
+        mutation($projectId: ID!, $itemId: ID!) {
+            deleteProjectV2Item(input: {projectId: $projectId, itemId: $itemId}) {
+                deletedItemId
+            }
+        }
+        """
+        data = self._graphql_request(
+            mutation, {"projectId": project_id, "itemId": item_id}
+        )
+
+        deleted_id = data.get("deleteProjectV2Item", {}).get("deletedItemId")
+        return {
+            "success": True,
+            "issue_number": issue_number,
+            "project": project,
+            "deleted_item_id": deleted_id,
+        }
+
+    def get_project_fields(
+        self,
+        project: str,
+        owner: Optional[str] = None,
+        is_org: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get fields for a GitHub Project V2 with options for SingleSelect fields.
+
+        Args:
+            project: Project number (as string) or title
+            owner: Organization or user name
+            is_org: If True, treat owner as organization
+
+        Returns:
+            List of field dicts with id, name, data_type, and options for SingleSelect
+        """
+        owner = owner or self.default_owner
+        if not owner:
+            raise ValueError("Owner must be specified")
+
+        # Get project ID first
+        project_id = self.get_project_id(project, owner=owner, is_org=is_org)
+        if not project_id:
+            raise GithubException(
+                404, {"message": f"Project '{project}' not found for {owner}"}
+            )
+
+        # Query fields with options
+        query = """
+        query($projectId: ID!) {
+            node(id: $projectId) {
+                ... on ProjectV2 {
+                    fields(first: 100) {
+                        nodes {
+                            ... on ProjectV2FieldCommon {
+                                id
+                                name
+                                dataType
+                            }
+                            ... on ProjectV2SingleSelectField {
+                                options {
+                                    id
+                                    name
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        """
+        data = self._graphql_request(query, {"projectId": project_id})
+
+        node = data.get("node")
+        if not node:
+            return []
+
+        fields = []
+        for field in node.get("fields", {}).get("nodes", []):
+            if not field:
+                continue
+
+            field_data = {
+                "id": field.get("id"),
+                "name": field.get("name"),
+                "data_type": field.get("dataType"),
+            }
+
+            # Add options for SingleSelect fields
+            if "options" in field:
+                field_data["options"] = [
+                    {"id": opt["id"], "name": opt["name"]}
+                    for opt in field.get("options", [])
+                ]
+
+            fields.append(field_data)
+
+        return fields
+
+    def list_projects_with_fields(
+        self,
+        owner: Optional[str] = None,
+        is_org: bool = True,
+        limit: int = 20,
+    ) -> List[Dict[str, Any]]:
+        """
+        List GitHub Projects V2 with their fields in one GraphQL call.
+
+        More efficient than calling list_projects + get_project_fields separately.
+
+        Args:
+            owner: Organization or user name. Uses default_owner if not specified.
+            is_org: If True, treat owner as organization. If False, treat as user.
+            limit: Maximum projects to return (default: 20)
+
+        Returns:
+            List of project dicts with id, number, title, url, closed, owner, fields
+        """
+        owner = owner or self.default_owner
+        if not owner:
+            raise ValueError("Owner must be specified for listing projects")
+
+        if is_org:
+            query = """
+            query($owner: String!, $limit: Int!) {
+                organization(login: $owner) {
+                    projectsV2(first: $limit, orderBy: {field: UPDATED_AT, direction: DESC}) {
+                        nodes {
+                            id
+                            number
+                            title
+                            url
+                            closed
+                            fields(first: 50) {
+                                nodes {
+                                    ... on ProjectV2FieldCommon {
+                                        id
+                                        name
+                                        dataType
+                                    }
+                                    ... on ProjectV2SingleSelectField {
+                                        options {
+                                            id
+                                            name
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            """
+            data = self._graphql_request(query, {"owner": owner, "limit": limit})
+            org = data.get("organization")
+            if not org:
+                # Try as user if org lookup fails
+                return self.list_projects_with_fields(
+                    owner=owner, is_org=False, limit=limit
+                )
+            nodes = org.get("projectsV2", {}).get("nodes", [])
+        else:
+            query = """
+            query($owner: String!, $limit: Int!) {
+                user(login: $owner) {
+                    projectsV2(first: $limit, orderBy: {field: UPDATED_AT, direction: DESC}) {
+                        nodes {
+                            id
+                            number
+                            title
+                            url
+                            closed
+                            fields(first: 50) {
+                                nodes {
+                                    ... on ProjectV2FieldCommon {
+                                        id
+                                        name
+                                        dataType
+                                    }
+                                    ... on ProjectV2SingleSelectField {
+                                        options {
+                                            id
+                                            name
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            """
+            data = self._graphql_request(query, {"owner": owner, "limit": limit})
+            user = data.get("user")
+            if not user:
+                return []
+            nodes = user.get("projectsV2", {}).get("nodes", [])
+
+        projects = []
+        for node in nodes:
+            if not node:
+                continue
+
+            # Parse fields
+            fields = []
+            for field in node.get("fields", {}).get("nodes", []):
+                if not field:
+                    continue
+
+                field_data = {
+                    "id": field.get("id"),
+                    "name": field.get("name"),
+                    "data_type": field.get("dataType"),
+                }
+
+                # Add options for SingleSelect fields
+                if "options" in field:
+                    field_data["options"] = [
+                        {"id": opt["id"], "name": opt["name"]}
+                        for opt in field.get("options", [])
+                    ]
+
+                fields.append(field_data)
+
+            projects.append(
+                {
+                    "id": node["id"],
+                    "number": node["number"],
+                    "title": node["title"],
+                    "url": node["url"],
+                    "closed": node["closed"],
+                    "owner": owner,
+                    "fields": fields,
+                }
+            )
+
+        return projects
+
+    def get_project_item_id(
+        self,
+        issue_number: int,
+        project: str,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+        project_owner: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Get the project item ID for an issue in a project.
+
+        The project item ID is required for updating field values.
+
+        Args:
+            issue_number: Issue number
+            project: Project number (as string) or title
+            owner: Repository owner (for the issue)
+            repo: Repository name
+            project_owner: Owner of the project (org or user). Defaults to repo owner.
+
+        Returns:
+            Project item ID or None if issue not in project
+        """
+        owner = owner or self.default_owner
+        repo = repo or self.default_repo
+        project_owner = project_owner or owner
+
+        if not owner or not repo:
+            raise ValueError("Repository owner and name must be specified")
+
+        # Get project ID
+        project_id = self.get_project_id(project, owner=project_owner, is_org=True)
+        if not project_id:
+            raise GithubException(
+                404, {"message": f"Project '{project}' not found for {project_owner}"}
+            )
+
+        # Get issue node ID
+        issue_node_id = self.get_issue_node_id(issue_number, owner=owner, repo=repo)
+
+        # Search for the item in the project
+        query = """
+        query($projectId: ID!, $cursor: String) {
+            node(id: $projectId) {
+                ... on ProjectV2 {
+                    items(first: 100, after: $cursor) {
+                        nodes {
+                            id
+                            content {
+                                ... on Issue {
+                                    id
+                                    number
+                                }
+                            }
+                        }
+                        pageInfo {
+                            hasNextPage
+                            endCursor
+                        }
+                    }
+                }
+            }
+        }
+        """
+
+        cursor = None
+        while True:
+            data = self._graphql_request(
+                query, {"projectId": project_id, "cursor": cursor}
+            )
+            node = data.get("node", {})
+            items = node.get("items", {})
+
+            for item in items.get("nodes", []):
+                content = item.get("content")
+                if content and content.get("id") == issue_node_id:
+                    return item["id"]
+
+            page_info = items.get("pageInfo", {})
+            if not page_info.get("hasNextPage"):
+                break
+            cursor = page_info.get("endCursor")
+
+        return None
+
+    def update_project_item_field(
+        self,
+        issue_number: int,
+        project: str,
+        field_name: str,
+        value: str,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+        project_owner: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update a field value for an issue in a GitHub Project V2.
+
+        Supports different field types:
+        - SINGLE_SELECT: value is the option name (e.g., "In Progress")
+        - TEXT: value is the text content
+        - NUMBER: value is the number as string
+        - DATE: value is ISO date format (YYYY-MM-DD)
+
+        Args:
+            issue_number: Issue number
+            project: Project number (as string) or title
+            field_name: Field name (e.g., "Status", "Priority")
+            value: Field value (option name for SingleSelect, text for others)
+            owner: Repository owner (for the issue)
+            repo: Repository name
+            project_owner: Owner of the project (org or user). Defaults to repo owner.
+
+        Returns:
+            Dict with success status and updated info
+
+        Raises:
+            GithubException: If project, field, or option not found
+        """
+        owner = owner or self.default_owner
+        repo = repo or self.default_repo
+        project_owner = project_owner or owner
+
+        if not owner or not repo:
+            raise ValueError("Repository owner and name must be specified")
+
+        # Get project ID
+        project_id = self.get_project_id(project, owner=project_owner, is_org=True)
+        if not project_id:
+            raise GithubException(
+                404, {"message": f"Project '{project}' not found for {project_owner}"}
+            )
+
+        # Get project item ID (issue must be in project)
+        item_id = self.get_project_item_id(
+            issue_number=issue_number,
+            project=project,
+            owner=owner,
+            repo=repo,
+            project_owner=project_owner,
+        )
+        if not item_id:
+            raise GithubException(
+                404,
+                {
+                    "message": f"Issue #{issue_number} not found in project '{project}'. Add it first with add_to_project."
+                },
+            )
+
+        # Get fields to find the field ID and type
+        fields = self.get_project_fields(project, owner=project_owner, is_org=True)
+
+        # Find the field by name (case-insensitive)
+        field = None
+        for f in fields:
+            if f["name"].lower() == field_name.lower():
+                field = f
+                break
+
+        if not field:
+            available_fields = [f["name"] for f in fields]
+            raise GithubException(
+                404,
+                {
+                    "message": f"Field '{field_name}' not found in project. Available fields: {available_fields}"
+                },
+            )
+
+        field_id = field["id"]
+        data_type = field.get("data_type")
+
+        # Build the value based on field type
+        if data_type == "SINGLE_SELECT":
+            # Find the option ID by name
+            options = field.get("options", [])
+            option_id = None
+            for opt in options:
+                if opt["name"].lower() == value.lower():
+                    option_id = opt["id"]
+                    break
+
+            if not option_id:
+                available_options = [opt["name"] for opt in options]
+                raise GithubException(
+                    400,
+                    {
+                        "message": f"Option '{value}' not found for field '{field_name}'. Available options: {available_options}"
+                    },
+                )
+
+            field_value = {"singleSelectOptionId": option_id}
+
+        elif data_type == "TEXT":
+            field_value = {"text": value}
+
+        elif data_type == "NUMBER":
+            try:
+                field_value = {"number": float(value)}
+            except ValueError:
+                raise GithubException(
+                    400,
+                    {
+                        "message": f"Invalid number value '{value}' for field '{field_name}'"
+                    },
+                )
+
+        elif data_type == "DATE":
+            field_value = {"date": value}
+
+        else:
+            raise GithubException(
+                400,
+                {
+                    "message": f"Field type '{data_type}' not supported for updates. Supported: SINGLE_SELECT, TEXT, NUMBER, DATE"
+                },
+            )
+
+        # Execute the mutation
+        mutation = """
+        mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: ProjectV2FieldValue!) {
+            updateProjectV2ItemFieldValue(input: {
+                projectId: $projectId,
+                itemId: $itemId,
+                fieldId: $fieldId,
+                value: $value
+            }) {
+                projectV2Item {
+                    id
+                }
+            }
+        }
+        """
+
+        data = self._graphql_request(
+            mutation,
+            {
+                "projectId": project_id,
+                "itemId": item_id,
+                "fieldId": field_id,
+                "value": field_value,
+            },
+        )
+
+        updated_item = data.get("updateProjectV2ItemFieldValue", {}).get(
+            "projectV2Item"
+        )
+
+        return {
+            "success": True,
+            "issue_number": issue_number,
+            "project": project,
+            "field": field_name,
+            "value": value,
+            "item_id": updated_item["id"] if updated_item else item_id,
+        }

mcp_server/resources/github_resources.py

@@ -114,3 +114,127 @@ def create_github_resources(mcp: FastMCP) -> None:
         )
 
         return "\n".join(lines)
+
+    @mcp.resource("github://projects")
+    def get_github_projects() -> str:
+        """
+        List of GitHub Projects V2 with their fields and options.
+
+        Use these for project management operations like updating issue status.
+        """
+        store = get_credential_store()
+
+        # Check if authenticated via PAT or QuickCall
+        pat_token, pat_source = get_github_pat()
+        has_pat = pat_token is not None
+
+        if not has_pat and not store.is_authenticated():
+            return "GitHub not connected. Options:\n- Run connect_github_via_pat with a Personal Access Token\n- Run connect_quickcall to use QuickCall"
+
+        # Check QuickCall GitHub App connection
+        has_app = False
+        if store.is_authenticated():
+            creds = store.get_api_credentials()
+            if creds and creds.github_connected and creds.github_token:
+                has_app = True
+
+        if not has_pat and not has_app:
+            return "GitHub not connected. Connect at quickcall.dev/assistant or use connect_github_via_pat."
+
+        try:
+            # Import here to avoid circular imports
+            from mcp_server.tools.github_tools import _get_client
+
+            client = _get_client()
+
+            # Determine auth mode for display
+            auth_mode = "PAT" if has_pat else "GitHub App"
+
+            # Get the authenticated user
+            username = client.get_authenticated_user()
+
+            # Collect all projects from user and their orgs
+            all_projects = []
+
+            # 1. Try user projects first
+            try:
+                user_projects = client.list_projects_with_fields(
+                    owner=username, is_org=False, limit=100
+                )
+                all_projects.extend(user_projects)
+            except Exception:
+                pass
+
+            # 2. Get unique orgs from repos the user has access to
+            try:
+                repos = client.list_repos(limit=100)
+                org_counts: dict = {}
+                for repo in repos:
+                    if repo.owner != username:
+                        org_counts[repo.owner] = org_counts.get(repo.owner, 0) + 1
+
+                # Sort orgs by repo count (most repos first)
+                sorted_orgs = sorted(
+                    org_counts.keys(), key=lambda x: org_counts[x], reverse=True
+                )
+
+                # Fetch projects from all orgs
+                for org in sorted_orgs:
+                    try:
+                        org_projects = client.list_projects_with_fields(
+                            owner=org, is_org=True, limit=100
+                        )
+                        all_projects.extend(org_projects)
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
+            if not all_projects:
+                return (
+                    f"GitHub Projects (via {auth_mode}):\n\n"
+                    f"No projects found for {username} or accessible orgs.\n\n"
+                    "To list projects for a specific org, use:\n"
+                    "  manage_issues(action='list_projects', owner='org-name')"
+                )
+
+            projects = all_projects
+
+            lines = [f"GitHub Projects (via {auth_mode}):", ""]
+
+            for proj in projects:
+                status = "closed" if proj["closed"] else "open"
+                lines.append(f"- #{proj['number']}: {proj['title']} ({status})")
+                lines.append(f"  URL: {proj['url']}")
+
+                # Show fields
+                fields = proj.get("fields", [])
+                if fields:
+                    lines.append("  Fields:")
+                    for field in fields:
+                        name = field.get("name", "Unknown")
+                        data_type = field.get("data_type", "UNKNOWN")
+
+                        if data_type == "SINGLE_SELECT":
+                            options = field.get("options", [])
+                            option_names = [opt["name"] for opt in options]
+                            lines.append(
+                                f"    - {name} (SINGLE_SELECT): {', '.join(option_names)}"
+                            )
+                        else:
+                            lines.append(f"    - {name} ({data_type})")
+
+                lines.append("")
+
+            lines.append("Usage:")
+            lines.append(
+                "  manage_projects(action='update_fields', issue_numbers=[42], project='1',"
+            )
+            lines.append(
+                "                  fields={'Status': 'In Progress', 'Priority': 'High'})"
+            )
+
+            return "\n".join(lines)
+        except Exception as e:
+            logger.error(f"Failed to fetch GitHub projects: {e}")
+            return f"Error fetching projects: {str(e)}"

mcp_server/tools/github_tools.py

@@ -575,7 +575,7 @@ def create_github_tools(mcp: FastMCP) -> None:
         ),
         issue_numbers: Optional[List[int]] = Field(
             default=None,
-            description="Issue number(s). Required for view/update/close/reopen/comment/sub-issue ops.",
+            description="Issue number(s). Required for view/update/close/reopen/comment/sub-issue/project ops.",
         ),
         title: Optional[str] = Field(
             default=None,
@@ -647,6 +647,8 @@ def create_github_tools(mcp: FastMCP) -> None:
         - add sub-issues: manage_issues(action="add_sub_issue", issue_numbers=[43,44], parent_issue=42)
         - remove sub-issue: manage_issues(action="remove_sub_issue", issue_numbers=[43], parent_issue=42)
         - list sub-issues: manage_issues(action="list_sub_issues", parent_issue=42)
+
+        For project operations (add to project, update fields), use manage_projects() instead.
         """
         try:
             client = _get_client()
@@ -1091,3 +1093,237 @@ def create_github_tools(mcp: FastMCP) -> None:
                 "connected": False,
                 "error": str(e),
             }
+
+    @mcp.tool(tags={"github", "projects"})
+    def manage_projects(
+        action: str = Field(
+            ...,
+            description="Action: 'list', 'add', 'remove', 'update_fields'",
+        ),
+        issue_numbers: Optional[List[int]] = Field(
+            default=None,
+            description="Issue number(s) for add/remove/update_fields actions.",
+        ),
+        project: Optional[str] = Field(
+            default=None,
+            description="Project number or title. Required for add/remove/update_fields.",
+        ),
+        fields: Optional[Dict[str, str]] = Field(
+            default=None,
+            description="Dict of field names to values for 'add' or 'update_fields'. "
+            "Example: {'Status': 'In Progress', 'Priority': 'High'}",
+        ),
+        owner: Optional[str] = Field(
+            default=None,
+            description="Repository owner (for the issues).",
+        ),
+        repo: Optional[str] = Field(
+            default=None,
+            description="Repository name (for the issues).",
+        ),
+        project_owner: Optional[str] = Field(
+            default=None,
+            description="Owner of the project (org or user). Defaults to repo owner.",
+        ),
+        limit: Optional[int] = Field(
+            default=20,
+            description="Maximum projects to return for 'list' action.",
+        ),
+    ) -> dict:
+        """
+        Manage GitHub Projects V2: list projects, add/remove issues, update fields.
+
+        IMPORTANT: Use 'add' with 'fields' to add issue AND set fields in ONE call.
+        Don't make separate calls for add + update_fields.
+
+        Examples:
+        - list: manage_projects(action="list", owner="org-name")
+        - add with fields: manage_projects(action="add", issue_numbers=[42], project="1",
+                           fields={"Status": "Triage", "Priority": "High"}, repo="my-repo")
+        - add only: manage_projects(action="add", issue_numbers=[42], project="1", repo="my-repo")
+        - remove: manage_projects(action="remove", issue_numbers=[42], project="1", repo="my-repo")
+        - update fields: manage_projects(action="update_fields", issue_numbers=[42], project="1",
+                         fields={"Status": "In Progress"}, repo="my-repo")
+        """
+        try:
+            client = _get_client()
+
+            # === LIST ACTION ===
+            if action == "list":
+                proj_owner = project_owner or owner
+                if not proj_owner:
+                    # Use authenticated user if no owner specified
+                    proj_owner = client.get_authenticated_user()
+
+                projects = client.list_projects(
+                    owner=proj_owner,
+                    is_org=True,  # Try org first, falls back to user
+                    limit=limit or 20,
+                )
+                return {
+                    "action": "list",
+                    "owner": proj_owner,
+                    "count": len(projects),
+                    "projects": projects,
+                }
+
+            # === ADD ACTION ===
+            if action == "add":
+                if not project:
+                    raise ToolError("'project' is required for 'add' action")
+                if not issue_numbers:
+                    raise ToolError("'issue_numbers' is required for 'add' action")
+
+                results = []
+                for issue_number in issue_numbers:
+                    issue_result = {
+                        "number": issue_number,
+                        "project": project,
+                    }
+                    try:
+                        result = client.add_issue_to_project(
+                            issue_number=issue_number,
+                            project=project,
+                            owner=owner,
+                            repo=repo,
+                            project_owner=project_owner,
+                        )
+                        issue_result["status"] = "added"
+                        issue_result["project_item_id"] = result.get("project_item_id")
+
+                        # If fields provided, set them after adding
+                        if fields:
+                            issue_result["fields_updated"] = []
+                            issue_result["field_errors"] = []
+                            for field_name, value in fields.items():
+                                try:
+                                    client.update_project_item_field(
+                                        issue_number=issue_number,
+                                        project=project,
+                                        field_name=field_name,
+                                        value=value,
+                                        owner=owner,
+                                        repo=repo,
+                                        project_owner=project_owner,
+                                    )
+                                    issue_result["fields_updated"].append(
+                                        {"field": field_name, "value": value}
+                                    )
+                                except Exception as e:
+                                    issue_result["field_errors"].append(
+                                        {"field": field_name, "error": str(e)}
+                                    )
+
+                        results.append(issue_result)
+                    except Exception as e:
+                        issue_result["status"] = "error"
+                        issue_result["error"] = str(e)
+                        results.append(issue_result)
+
+                return {
+                    "action": "add",
+                    "project": project,
+                    "count": len(results),
+                    "results": results,
+                }
+
+            # === REMOVE ACTION ===
+            if action == "remove":
+                if not project:
+                    raise ToolError("'project' is required for 'remove' action")
+                if not issue_numbers:
+                    raise ToolError("'issue_numbers' is required for 'remove' action")
+
+                results = []
+                for issue_number in issue_numbers:
+                    try:
+                        client.remove_issue_from_project(
+                            issue_number=issue_number,
+                            project=project,
+                            owner=owner,
+                            repo=repo,
+                            project_owner=project_owner,
+                        )
+                        results.append(
+                            {
+                                "number": issue_number,
+                                "status": "removed",
+                                "project": project,
+                            }
+                        )
+                    except Exception as e:
+                        results.append(
+                            {
+                                "number": issue_number,
+                                "status": "error",
+                                "error": str(e),
+                            }
+                        )
+
+                return {
+                    "action": "remove",
+                    "project": project,
+                    "count": len(results),
+                    "results": results,
+                }
+
+            # === UPDATE FIELDS ACTION ===
+            if action == "update_fields":
+                if not project:
+                    raise ToolError("'project' is required for 'update_fields' action")
+                if not issue_numbers:
+                    raise ToolError(
+                        "'issue_numbers' is required for 'update_fields' action"
+                    )
+                if not fields:
+                    raise ToolError("'fields' is required for 'update_fields' action")
+
+                results = []
+                for issue_number in issue_numbers:
+                    issue_result = {
+                        "number": issue_number,
+                        "fields_updated": [],
+                        "errors": [],
+                    }
+
+                    for field_name, value in fields.items():
+                        try:
+                            client.update_project_item_field(
+                                issue_number=issue_number,
+                                project=project,
+                                field_name=field_name,
+                                value=value,
+                                owner=owner,
+                                repo=repo,
+                                project_owner=project_owner,
+                            )
+                            issue_result["fields_updated"].append(
+                                {"field": field_name, "value": value}
+                            )
+                        except Exception as e:
+                            issue_result["errors"].append(
+                                {"field": field_name, "error": str(e)}
+                            )
+
+                    issue_result["status"] = (
+                        "success" if not issue_result["errors"] else "partial"
+                    )
+                    results.append(issue_result)
+
+                return {
+                    "action": "update_fields",
+                    "project": project,
+                    "count": len(results),
+                    "results": results,
+                }
+
+            raise ToolError(
+                f"Invalid action: {action}. Valid actions: list, add, remove, update_fields"
+            )
+
+        except ToolError:
+            raise
+        except ValueError as e:
+            raise ToolError(f"Invalid parameters: {str(e)}")
+        except Exception as e:
+            raise ToolError(f"Failed to {action} project: {str(e)}")

{quickcall_integrations-0.3.9.dist-info → quickcall_integrations-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quickcall-integrations
-Version: 0.3.9
+Version: 0.4.0
 Summary: MCP server with developer integrations for Claude Code and Cursor
 Requires-Python: >=3.10
 Requires-Dist: fastmcp>=2.13.0

{quickcall_integrations-0.3.9.dist-info → quickcall_integrations-0.4.0.dist-info}/RECORD

@@ -1,21 +1,21 @@
 mcp_server/__init__.py,sha256=6KGzjSPyVB6vQh150DwBjINM_CsZNDhOzwSQFWpXz0U,301
 mcp_server/server.py,sha256=kv5hh0J-M7yENUBBNI1bkq1y7MB0zn5R_-R1tib6_sk,3108
 mcp_server/api_clients/__init__.py,sha256=kOG5_sxIVpAx_tvf1nq_P0QCkqojAVidRE-wenLS-Wc,207
-mcp_server/api_clients/github_client.py,sha256=Mlh6BzMhZ05NqkX9A2O80eJIQXWuW4FnnN1DBM0WKC8,40135
+mcp_server/api_clients/github_client.py,sha256=Y3P2yRRv8GxG0xjql6IaVB5aodGDeTPQUC_lHQmgVWM,70829
 mcp_server/api_clients/slack_client.py,sha256=w3rcGghttfYw8Ird2beNo2LEYLc3rCTbUKMH4X7QQuQ,16447
 mcp_server/auth/__init__.py,sha256=D-JS0Qe7FkeJjYx92u_AqPx8ZRoB3dKMowzzJXlX6cc,780
 mcp_server/auth/credentials.py,sha256=sDS0W5c16i_UGvhG8Sh1RO93FxRn-hHVAdI9hlWuhx0,20011
 mcp_server/auth/device_flow.py,sha256=NXNWHzd-CA4dlhEVCgUhwfpe9TpMKpLSJuyFCh70xKs,8371
 mcp_server/resources/__init__.py,sha256=JrMa3Kf-DmeCB4GwVNfmfw9OGnxF9pJJxCw9Y7u7ujQ,35
-mcp_server/resources/github_resources.py,sha256=sXE06j9jrSDODxH2832fiCtY9n1lKBQR8QZ8U5wYbJY,4030
+mcp_server/resources/github_resources.py,sha256=b7S5Jd-xcS6OjceOdwsJZ-BLfIolQXZ9LnQhlhigfb0,8850
 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=BPuj9M0pZOvvWHxH0HPdiVm-Y6DJyD-PEvtrIh68vbc,25409
 mcp_server/tools/git_tools.py,sha256=jyCTQR2eSzUFXMt0Y8x66758-VY8YCY14DDUJt7GY2U,13957
-mcp_server/tools/github_tools.py,sha256=2YE0RtkfartAuLVUciVFuycqc-B3OhN0uNPwhDm1t48,40053
+mcp_server/tools/github_tools.py,sha256=U1auskC17nJWVmqFO9EITe-OcDSeDBuhM3d4iox7Ix8,50007
 mcp_server/tools/slack_tools.py,sha256=-HVE_x3Z1KMeYGi1xhyppEwz5ZF-I-ZD0-Up8yBeoYE,11796
 mcp_server/tools/utility_tools.py,sha256=oxAXpdqtPeB5Ug5dvk54V504r-8v1AO4_px-sO6LFOw,3910
-quickcall_integrations-0.3.9.dist-info/METADATA,sha256=thgEYROxcB1cBO4BsAunkrS9BIYtyTmLWTe3Fci5qSI,9415
-quickcall_integrations-0.3.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quickcall_integrations-0.3.9.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
-quickcall_integrations-0.3.9.dist-info/RECORD,,
+quickcall_integrations-0.4.0.dist-info/METADATA,sha256=pOcoe0a2JKylPL6tpzYk2lUor_hgfsXPyDgjwjn45JM,9415
+quickcall_integrations-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quickcall_integrations-0.4.0.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
+quickcall_integrations-0.4.0.dist-info/RECORD,,