redmine-mcp-stateless

Instructions

Args:
    assigned_to_id: Assignee ID (obtain via list_users)
    project_id: Project ID (all projects if omitted)
    status_id: Status ID or "open" / "closed" / "*"
    limit: Number of issues to fetch (max 100)
    offset: Starting offset

Implementation Reference

• redmine_mcp_server.py:193-236 (handler)

  The core implementation of the tool, which fetches issues and their associated journals from the Redmine API.

  def list_issues_with_journals(
      self,
      assigned_to_id: Optional[int] = None,
      project_id: Optional[str] = None,
      status_id: Optional[str] = None,
      limit: int = 25,
      offset: int = 0,
  ) -> List[Dict[str, Any]]:
      try:
          kwargs: Dict[str, Any] = {"limit": limit, "offset": offset}
          if assigned_to_id is not None:
              kwargs["assigned_to_id"] = assigned_to_id
          if project_id is not None:
              kwargs["project_id"] = project_id
          if status_id is not None:
              kwargs["status_id"] = status_id
          issues = self._redmine.issue.filter(**kwargs)
          result = []
          for issue in issues:
              full = self._redmine.issue.get(issue.id, include=["journals"])
              journals = _safe(full, "journals", [])
              result.append({
                  "id": full.id,
                  "subject": full.subject,
                  "status": _safe(_safe(full, "status"), "name", ""),
                  "tracker": _safe(_safe(full, "tracker"), "name", ""),
                  "priority": _safe(_safe(full, "priority"), "name", ""),
                  "assigned_to": _safe(_safe(full, "assigned_to"), "name", ""),
                  "updated_on": str(_safe(full, "updated_on", "")),
                  "journals": [
                      {
                          "notes": _safe(j, "notes", ""),
                          "created_on": str(_safe(j, "created_on", "")),
                          "user": _safe(_safe(j, "user"), "name", ""),
                      }
                      for j in journals
                      if _safe(j, "notes")
                  ],
              })
          return result
      except (AuthError, ForbiddenError) as e:
          raise RedmineError(f"Authentication failed: {e}") from e
      except Exception as e:
          raise RedmineError(f"list_issues_with_journals failed: {e}") from e

• redmine_mcp_interface.py:319-349 (handler)

  The interface layer that exposes the list_issues_with_journals tool, delegating the logic to the Redmine server client.

  def list_issues_with_journals(
      assigned_to_id: Optional[int] = None,
      project_id: Optional[str] = None,
      status_id: Optional[str] = None,
      limit: int = 25,
      offset: int = 0,
  ) -> List[Dict[str, Any]]:
      """Returns a list of issues with all comments. Useful for reviewing progress per assignee.
  
      Args:
          assigned_to_id: Assignee ID (obtain via list_users)
          project_id: Project ID (all projects if omitted)
          status_id: Status ID or "open" / "closed" / "*"
          limit: Number of issues to fetch (max 100)
          offset: Starting offset
      """
      logger.info(
          f"tool=list_issues_with_journals assigned_to_id={assigned_to_id} "
          f"project_id={project_id} status_id={status_id} limit={limit}"
      )
      try:
          return _client().list_issues_with_journals(
              assigned_to_id=assigned_to_id,
              project_id=project_id,
              status_id=status_id,
              limit=limit,
              offset=offset,
          )
      except RedmineError as e:
          logger.error(f"list_issues_with_journals error: {e}")
          raise