Add create command for project issues

Author: yieldthought

README.md

@@ -46,6 +46,15 @@ project.release(2)
 # context-managed lease (auto-release on exit)
 with project.lease("Backlog") as issue:
     print(issue.number)
+
+# create a new issue and add it to the project
+issue = project.create(
+    title="Investigate latency spikes",
+    description="See logs from Jan 24",
+    status="Backlog",
+    repo="yieldthought/gh-task",  # optional if the project has a single repo
+    label="bug",
+)
 ```
 
 ## CLI
@@ -66,6 +75,10 @@ with project.lease("Backlog") as issue:
 # move and release
  gh-task move -p yieldthought/projects/3 -n my-name -i 2 -s "In review"
  gh-task release -p yieldthought/projects/3 -n my-name -i 2
+
+# create a new issue and add it to the project (repo inferred if possible)
+ gh-task create -p yieldthought/projects/3 -r yieldthought/gh-task -t "Fix retry logic" -d "Add jitter + cap"
+ gh-task create -p yieldthought/projects/3 -t "Investigate latency spikes" -s Backlog --label bug
 ```
 
 ## Label filtering

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gh-task"
-version = "0.1.5"
+version = "0.1.6"
 description = "Python + CLI helpers for GitHub Projects task ownership"
 readme = "README.md"
 requires-python = ">=3.9"

src/gh_task/__init__.py

@@ -1,6 +1,7 @@
 from .errors import (
     ApiError,
     ConfigError,
+    CreateError,
     GhTaskError,
     MoveError,
     NotFoundError,
@@ -13,6 +14,7 @@
 __all__ = [
     "ApiError",
     "ConfigError",
+    "CreateError",
     "GhTaskError",
     "Issue",
     "IssueLease",

src/gh_task/cli.py

@@ -84,10 +84,40 @@ def main(argv: Optional[list[str]] = None) -> int:
     list_parser.add_argument("status", nargs="?", help="Status name to list issues for")
     list_parser.add_argument("-s", "--status-name", help="Status name to list issues for")
 
+    create_parser = subparsers.add_parser("create", help="Create an issue and add it to the project")
+    create_parser.add_argument(
+        "-p",
+        "--project",
+        required=True,
+        help="Project reference (e.g. yieldthought/projects/3 or full URL)",
+    )
+    create_parser.add_argument("--token", help="GitHub token (defaults to GH_TOKEN/GITHUB_TOKEN or gh auth)")
+    create_parser.add_argument("-r", "--repo", help="Repo name (owner/repo)")
+    create_parser.add_argument("-t", "--title", required=True, help="Issue title")
+    create_parser.add_argument("-d", "--description", help="Issue description/body")
+    create_parser.add_argument("-s", "--status", default="Backlog", help="Status name (default: Backlog)")
+    create_parser.add_argument(
+        "-l",
+        "--label",
+        help="Label to add to the issue (created if missing)",
+    )
+
     args = parser.parse_args(argv)
-    labels = _parse_label_filter(args.label)
 
     try:
+        if args.command == "create":
+            project = Project(project=args.project, token=args.token)
+            result = project.create(
+                title=args.title,
+                description=args.description,
+                status=args.status,
+                repo=args.repo,
+                label=args.label,
+            )
+            print(f"{_format_issue(result)} -> {result.status}")
+            return 0
+
+        labels = _parse_label_filter(args.label)
         project = Project(project=args.project, name=args.name, token=args.token, has_label=labels)
 
         if args.command == "take":

src/gh_task/errors.py

@@ -33,3 +33,7 @@ class MoveError(GhTaskError):
 
 class ReleaseError(GhTaskError):
     """Raised when a release operation fails."""
+
+
+class CreateError(GhTaskError):
+    """Raised when a create operation fails."""

src/gh_task/project.py

@@ -5,7 +5,16 @@
 from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 from urllib.parse import quote
 
-from .errors import ApiError, ConfigError, MoveError, NotFoundError, OwnershipError, ReleaseError, TakeError
+from .errors import (
+    ApiError,
+    ConfigError,
+    CreateError,
+    MoveError,
+    NotFoundError,
+    OwnershipError,
+    ReleaseError,
+    TakeError,
+)
 from .github import GitHubClient
 
 
@@ -140,6 +149,14 @@
 }
 """
 
+ADD_ITEM_MUTATION = """
+mutation($projectId: ID!, $contentId: ID!) {
+  addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+    item { id }
+  }
+}
+"""
+
 COMMENT_VISIBILITY_TIMEOUT_SECONDS = 60.0
 
 
@@ -179,29 +196,27 @@ class Project:
     def __init__(
         self,
         project: str,
-        name: str,
+        name: Optional[str] = None,
         token: Optional[str] = None,
         has_label: Optional[Union[str, Iterable[str]]] = None,
     ) -> None:
         """Create a Project helper.
 
         Args:
             project: Project reference (e.g. "owner/projects/3" or full URL).
-            name: Owner name used for the "owner: <name>" label.
+            name: Owner name used for the "owner: <name>" label (required for take/move/release).
             token: GitHub token; defaults to GH_TOKEN/GITHUB_TOKEN or gh auth token.
             has_label: Optional label filter (string or list). When set, only issues
                 with at least one matching label are considered by list/take.
         """
         if not project:
             raise ConfigError("Project reference is required")
-        if not name:
-            raise ConfigError("Owner name is required")
         self.client = GitHubClient(token=token)
         self.owner, self.number = _parse_project_ref(project)
         if self.owner == "@me":
             self.owner = self._viewer_login()
         self.name = name
-        self.owner_label = f"owner: {self.name}"
+        self.owner_label = f"owner: {self.name}" if self.name else None
         self._label_filter = _normalize_label_filter(has_label)
         self._project_id: Optional[str] = None
         self._status_field_id: Optional[str] = None
@@ -217,6 +232,10 @@ def __enter__(self) -> "Project":
     def __exit__(self, exc_type, exc, tb) -> bool:
         return False
 
+    def _require_owner_name(self) -> None:
+        if not self.name:
+            raise ConfigError("Owner name is required for this operation")
+
     def statuses(self) -> List[str]:
         """Return the available status column names."""
         self._ensure_project_loaded()
@@ -251,6 +270,7 @@ def take(
 
         If a label filter is set, only matching issues are eligible.
         """
+        self._require_owner_name()
         if issue_id is None and status is None:
             raise TakeError("Provide an issue id or a status to take")
         if status is None and issue_id is not None and _looks_like_status(issue_id):
@@ -298,6 +318,7 @@ def lease(
 
     def move(self, issue_id: Union[int, str, Issue], status: str, *, repo: Optional[str] = None) -> Issue:
         """Move an owned issue to a new status column."""
+        self._require_owner_name()
         issue = self._resolve_issue(issue_id, repo=repo, require_project_item=True)
         if not self._is_owned_by_me(issue):
             raise OwnershipError(f"You do not own issue {issue.repo}#{issue.number}")
@@ -334,6 +355,7 @@ def set_number_field(
         repo: Optional[str] = None,
     ) -> Issue:
         """Set a numeric project field value on an owned issue."""
+        self._require_owner_name()
         issue = self._resolve_issue(issue_id, repo=repo, require_project_item=True)
         if not self._is_owned_by_me(issue):
             raise OwnershipError(f"You do not own issue {issue.repo}#{issue.number}")
@@ -417,6 +439,7 @@ def get_issue(
 
     def release(self, issue_id: Union[int, str, Issue], *, repo: Optional[str] = None) -> Issue:
         """Release an owned issue by removing the owner label."""
+        self._require_owner_name()
         issue = self._resolve_issue(issue_id, repo=repo)
         if not self._is_owned_by_me(issue):
             raise OwnershipError(f"You do not own issue {issue.repo}#{issue.number}")
@@ -426,6 +449,81 @@ def release(self, issue_id: Union[int, str, Issue], *, repo: Optional[str] = Non
             raise ReleaseError(f"Failed to release issue {issue.repo}#{issue.number}") from exc
         return issue
 
+    def create(
+        self,
+        title: str,
+        description: Optional[str] = None,
+        status: str = "Backlog",
+        *,
+        repo: Optional[str] = None,
+        label: Optional[str] = None,
+    ) -> Issue:
+        """Create an issue, add it to the project, and set its status."""
+        if not title or not str(title).strip():
+            raise ConfigError("Issue title is required")
+        target_repo = repo or self._infer_repo()
+        if not target_repo or "/" not in target_repo:
+            raise ConfigError("Repo must be in owner/repo format")
+
+        label_name = label.strip() if label is not None else None
+        if label is not None and not label_name:
+            raise ConfigError("Label must be non-empty")
+        if label_name:
+            self._ensure_label(target_repo, label_name, description="Created by gh-task")
+
+        owner, name = target_repo.split("/", 1)
+        payload: Dict[str, Any] = {"title": title, "body": description or ""}
+        if label_name:
+            payload["labels"] = [label_name]
+
+        try:
+            issue_data = self.client.rest("POST", f"repos/{owner}/{name}/issues", json_body=payload)
+        except Exception as exc:
+            raise CreateError(f"Failed to create issue in {target_repo}") from exc
+
+        number = issue_data.get("number")
+        content_id = issue_data.get("node_id")
+        if not content_id:
+            raise CreateError("Created issue is missing node id")
+
+        self._ensure_project_loaded()
+        status_name, option_id = self._resolve_status(status)
+        item_id: Optional[str] = None
+        try:
+            item_data = self.client.graphql(
+                ADD_ITEM_MUTATION,
+                {"projectId": self._project_id, "contentId": content_id},
+            )
+            item_id = ((item_data.get("addProjectV2ItemById") or {}).get("item") or {}).get("id")
+            if not item_id:
+                raise CreateError("Failed to add issue to project")
+            self.client.graphql(
+                UPDATE_STATUS_MUTATION,
+                {
+                    "projectId": self._project_id,
+                    "itemId": item_id,
+                    "fieldId": self._status_field_id,
+                    "optionId": option_id,
+                },
+            )
+        except CreateError:
+            raise
+        except Exception as exc:
+            raise CreateError(
+                f"Created issue {target_repo}#{number} but failed to add to project"
+            ) from exc
+
+        return Issue(
+            number=number,
+            repo=target_repo,
+            title=issue_data.get("title") or title,
+            url=issue_data.get("html_url"),
+            body=issue_data.get("body") if issue_data.get("body") is not None else (description or ""),
+            status=status_name,
+            project_item_id=item_id,
+            labels=[label_name] if label_name else None,
+        )
+
     def _wrap_take_result(self, issue: Issue, return_issue: bool, lease: bool):
         if lease:
             return IssueLease(self, issue)
@@ -586,6 +684,38 @@ def _list_items(self) -> List[Issue]:
             cursor = page_info.get("endCursor")
         return items
 
+    def _project_repos(self) -> List[str]:
+        self._ensure_project_loaded()
+        repos: set[str] = set()
+        cursor = None
+        while True:
+            data = self.client.graphql(
+                ITEMS_QUERY,
+                {"projectId": self._project_id, "cursor": cursor, "statusField": self._status_field_name},
+            )
+            node = data.get("node") or {}
+            project = node or {}
+            item_block = project.get("items") or {}
+            for raw in item_block.get("nodes") or []:
+                content = raw.get("content") or {}
+                if content.get("__typename") not in {"Issue", "PullRequest"}:
+                    continue
+                repo_info = content.get("repository") or {}
+                name_with_owner = repo_info.get("nameWithOwner")
+                if name_with_owner:
+                    repos.add(name_with_owner)
+            page_info = item_block.get("pageInfo") or {}
+            if not page_info.get("hasNextPage"):
+                break
+            cursor = page_info.get("endCursor")
+        return sorted(repos)
+
+    def _infer_repo(self) -> str:
+        repos = self._project_repos()
+        if len(repos) == 1:
+            return repos[0]
+        raise ConfigError("-r/--repo must be specified")
+
     def _resolve_status(self, status: str) -> Tuple[str, str]:
         self._ensure_project_loaded()
         status_name = self._resolve_status_name(status)
@@ -686,6 +816,8 @@ def _label_filter_hint(self) -> str:
         return f" (labels: {labels})"
 
     def _label_matches_owner(self, labels: Iterable[str]) -> bool:
+        if not self.owner_label:
+            return False
         needle = self.owner_label.lower()
         return any(label.lower() == needle for label in labels)