planpilot 2.2.0__tar.gz → 2.3.0__tar.gz

{planpilot-2.2.0 → planpilot-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: planpilot
-Version: 2.2.0
+Version: 2.3.0
 Summary: Sync roadmap plans (epics, stories, tasks) to GitHub Issues and Projects v2
 License: MIT
 License-File: LICENSE
@@ -221,6 +221,16 @@ planpilot sync --config ./planpilot.json --apply
 | `--apply` | — | Apply mode |
 | `--verbose` | off | Enable verbose logging |
 
+### `planpilot clean`
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--config` | `./planpilot.json` | Path to `planpilot.json` |
+| `--dry-run` | — | Preview which issues would be deleted |
+| `--apply` | — | Execute deletions |
+| `--all` | off | Delete all planpilot-managed issues by label, regardless of current plan hash |
+| `--verbose` | off | Enable verbose logging |
+
 ### `planpilot map sync`
 
 | Flag | Default | Description |

{planpilot-2.2.0 → planpilot-2.3.0}/README.md

@@ -187,6 +187,16 @@ planpilot sync --config ./planpilot.json --apply
 | `--apply` | — | Apply mode |
 | `--verbose` | off | Enable verbose logging |
 
+### `planpilot clean`
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--config` | `./planpilot.json` | Path to `planpilot.json` |
+| `--dry-run` | — | Preview which issues would be deleted |
+| `--apply` | — | Execute deletions |
+| `--all` | off | Delete all planpilot-managed issues by label, regardless of current plan hash |
+| `--verbose` | off | Enable verbose logging |
+
 ### `planpilot map sync`
 
 | Flag | Default | Description |

{planpilot-2.2.0 → planpilot-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "planpilot"
-version = "2.2.0"
+version = "2.3.0"
 description = "Sync roadmap plans (epics, stories, tasks) to GitHub Issues and Projects v2"
 readme = "README.md"
 license = "MIT"
@@ -69,7 +69,7 @@ test-e2e = "pytest -v tests/e2e/test_cli_e2e.py"
 coverage = "pytest -v --cov-report=html:.coverage/html"
 coverage-e2e = "pytest -v tests/e2e/test_cli_e2e.py --cov-report=term-missing --cov-report=xml:.coverage/coverage-e2e.xml"
 typecheck = "mypy src/planpilot"
-check = ["lint", "format-check", "test"]
+check = ["lint", "format-check", "typecheck", "test"]
 
 [tool.poe.tasks.gen-schema]
 help = "Introspect GitHub GraphQL API and download schema"

{planpilot-2.2.0 → planpilot-2.3.0}/src/planpilot/__init__.py

@@ -1,6 +1,6 @@
 """Public API surface for PlanPilot."""
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 
 from planpilot.auth import create_token_resolver
 from planpilot.contracts.config import FieldConfig, PlanPaths, PlanPilotConfig
@@ -16,7 +16,7 @@ from planpilot.contracts.exceptions import (
 from planpilot.contracts.plan import Plan, PlanItem, PlanItemType
 from planpilot.contracts.provider import Provider
 from planpilot.contracts.renderer import BodyRenderer, RenderContext
-from planpilot.contracts.sync import MapSyncResult, SyncEntry, SyncMap, SyncResult
+from planpilot.contracts.sync import CleanResult, MapSyncResult, SyncEntry, SyncMap, SyncResult
 from planpilot.providers import create_provider
 from planpilot.renderers import create_renderer
 from planpilot.scaffold import create_plan_stubs, detect_plan_paths, detect_target, scaffold_config, write_config
@@ -25,6 +25,7 @@ from planpilot.sdk import PlanPilot, load_config, load_plan
 __all__ = [
     "AuthenticationError",
     "BodyRenderer",
+    "CleanResult",
     "ConfigError",
     "FieldConfig",
     "MapSyncResult",

{planpilot-2.2.0 → planpilot-2.3.0}/src/planpilot/cli.py

@@ -13,6 +13,7 @@ import httpx
 
 from planpilot import (
     AuthenticationError,
+    CleanResult,
     ConfigError,
     MapSyncResult,
     PlanItemType,
@@ -31,6 +32,7 @@ from planpilot import (
     write_config,
 )
 from planpilot.contracts.exceptions import ProjectURLError
+from planpilot.engine.progress import SyncProgress
 from planpilot.providers.github.mapper import parse_project_url
 
 _REQUIRED_CLASSIC_SCOPES = {"repo", "project"}
@@ -85,20 +87,43 @@ def _check_classic_scopes(*, scopes_header: str | None) -> None:
         raise AuthenticationError(f"Token is missing required GitHub scopes: {needed}")
 
 
-def _validate_github_auth_for_init(*, token: str, target: str) -> str | None:
+def _validate_github_auth_for_init(*, token: str, target: str, progress: SyncProgress | None = None) -> str | None:
     owner, repo = target.split("/", 1)
     with httpx.Client(timeout=10.0) as client:
+        if progress is not None:
+            progress.phase_start("Init Auth")
         user_resp = client.get("https://api.github.com/user", headers=_github_headers(token))
         if user_resp.status_code != 200:
-            raise AuthenticationError("GitHub authentication failed; verify your token/gh login and network access")
-        _check_classic_scopes(scopes_header=user_resp.headers.get("x-oauth-scopes"))
-
+            auth_error = AuthenticationError(
+                "GitHub authentication failed; verify your token/gh login and network access"
+            )
+            if progress is not None:
+                progress.phase_error("Init Auth", auth_error)
+            raise auth_error
+        try:
+            _check_classic_scopes(scopes_header=user_resp.headers.get("x-oauth-scopes"))
+        except AuthenticationError as error:
+            if progress is not None:
+                progress.phase_error("Init Auth", error)
+            raise
+        if progress is not None:
+            progress.phase_done("Init Auth")
+
+        if progress is not None:
+            progress.phase_start("Init Repo")
         repo_resp = client.get(f"https://api.github.com/repos/{owner}/{repo}", headers=_github_headers(token))
         if repo_resp.status_code != 200:
-            raise AuthenticationError(
+            repo_error = AuthenticationError(
                 f"Cannot access target repository '{target}'; verify repo scope/permissions and repo visibility"
             )
-
+            if progress is not None:
+                progress.phase_error("Init Repo", repo_error)
+            raise repo_error
+        if progress is not None:
+            progress.phase_done("Init Repo")
+
+        if progress is not None:
+            progress.phase_start("Init Projects")
         viewer_projects_query = {"query": "query { viewer { projectsV2(first: 1) { nodes { id } } } }"}
         projects_resp = client.post(
             "https://api.github.com/graphql",
@@ -109,19 +134,34 @@ def _validate_github_auth_for_init(*, token: str, target: str) -> str | None:
             projects_resp.json() if projects_resp.headers.get("content-type", "").startswith("application/json") else {}
         )
         if projects_resp.status_code != 200 or payload.get("errors"):
-            raise AuthenticationError(
+            projects_error = AuthenticationError(
                 "Token does not have sufficient project permissions; ensure project access is granted"
             )
-
+            if progress is not None:
+                progress.phase_error("Init Projects", projects_error)
+            raise projects_error
+        if progress is not None:
+            progress.phase_done("Init Projects")
+
+        if progress is not None:
+            progress.phase_start("Init Owner")
         owner_resp = client.get(f"https://api.github.com/users/{owner}", headers=_github_headers(token))
         if owner_resp.status_code != 200:
+            if progress is not None:
+                progress.phase_done("Init Owner")
             return None
         owner_payload = owner_resp.json()
         owner_type = owner_payload.get("type")
         if owner_type == "Organization":
+            if progress is not None:
+                progress.phase_done("Init Owner")
             return "org"
         if owner_type == "User":
+            if progress is not None:
+                progress.phase_done("Init Owner")
             return "user"
+        if progress is not None:
+            progress.phase_done("Init Owner")
         return None
 
 
@@ -173,6 +213,19 @@ def build_parser() -> argparse.ArgumentParser:
     )
     init_parser.add_argument("--defaults", action="store_true", help="Use defaults without prompting")
 
+    clean_parser = subparsers.add_parser("clean", help="Delete all issues belonging to a plan")
+    clean_parser.add_argument("--config", default="./planpilot.json", help="Path to planpilot.json")
+    clean_mode = clean_parser.add_mutually_exclusive_group(required=True)
+    clean_mode.add_argument("--dry-run", action="store_true", help="Preview mode")
+    clean_mode.add_argument("--apply", action="store_true", help="Apply mode")
+    clean_parser.add_argument(
+        "--all",
+        action="store_true",
+        default=False,
+        help="Delete all planpilot-managed issues (by label), not just the current plan version",
+    )
+    clean_parser.add_argument("--verbose", "-v", action="store_true", help="Enable debug logging")
+
     map_parser = subparsers.add_parser("map", help="Sync-map operations")
     map_subparsers = map_parser.add_subparsers(dest="map_command", required=True)
 
@@ -210,13 +263,27 @@ async def _run_sync(args: argparse.Namespace) -> SyncResult:
 
 async def _run_map_sync(args: argparse.Namespace) -> MapSyncResult:
     config = load_config(args.config)
-    pp = await PlanPilot.from_config(config)
-    candidate_plan_ids = await pp.discover_remote_plan_ids()
-    selected_plan_id = _resolve_selected_plan_id(
-        explicit_plan_id=args.plan_id,
-        candidate_plan_ids=candidate_plan_ids,
-    )
-    result = await pp.map_sync(plan_id=selected_plan_id, dry_run=args.dry_run)
+    if not args.verbose:
+        from planpilot.progress import RichSyncProgress
+
+        with RichSyncProgress() as progress:
+            pp = await PlanPilot.from_config(config, progress=progress)
+            candidate_plan_ids = await pp.discover_remote_plan_ids()
+        selected_plan_id = _resolve_selected_plan_id(
+            explicit_plan_id=args.plan_id,
+            candidate_plan_ids=candidate_plan_ids,
+        )
+        with RichSyncProgress() as progress:
+            pp = await PlanPilot.from_config(config, progress=progress)
+            result = await pp.map_sync(plan_id=selected_plan_id, dry_run=args.dry_run)
+    else:
+        pp = await PlanPilot.from_config(config)
+        candidate_plan_ids = await pp.discover_remote_plan_ids()
+        selected_plan_id = _resolve_selected_plan_id(
+            explicit_plan_id=args.plan_id,
+            candidate_plan_ids=candidate_plan_ids,
+        )
+        result = await pp.map_sync(plan_id=selected_plan_id, dry_run=args.dry_run)
     result = result.model_copy(update={"candidate_plan_ids": candidate_plan_ids})
     print(_format_map_sync_summary(result, config))
     return result
@@ -253,15 +320,29 @@ def _format_summary(result: SyncResult, config: PlanPilotConfig) -> str:
     created_epics = result.items_created.get(PlanItemType.EPIC, 0)
     created_stories = result.items_created.get(PlanItemType.STORY, 0)
     created_tasks = result.items_created.get(PlanItemType.TASK, 0)
+    total_created = created_epics + created_stories + created_tasks
 
     total_by_type = {PlanItemType.EPIC: 0, PlanItemType.STORY: 0, PlanItemType.TASK: 0}
     for entry in result.sync_map.entries.values():
         if entry.item_type in total_by_type:
             total_by_type[entry.item_type] += 1
 
-    existing_epics = total_by_type[PlanItemType.EPIC] - created_epics
-    existing_stories = total_by_type[PlanItemType.STORY] - created_stories
-    existing_tasks = total_by_type[PlanItemType.TASK] - created_tasks
+    total_items = len(result.sync_map.entries)
+    total_matched = total_items - total_created
+
+    matched_epics = total_by_type[PlanItemType.EPIC] - created_epics
+    matched_stories = total_by_type[PlanItemType.STORY] - created_stories
+    matched_tasks = total_by_type[PlanItemType.TASK] - created_tasks
+
+    def _type_breakdown(epics: int, stories: int, tasks: int) -> str:
+        parts: list[str] = []
+        if epics:
+            parts.append(f"{epics} epic{'s' if epics != 1 else ''}")
+        if stories:
+            parts.append(f"{stories} stor{'ies' if stories != 1 else 'y'}")
+        if tasks:
+            parts.append(f"{tasks} task{'s' if tasks != 1 else ''}")
+        return ", ".join(parts) if parts else "none"
 
     lines = [
         "",
@@ -271,25 +352,22 @@ def _format_summary(result: SyncResult, config: PlanPilotConfig) -> str:
         f"  Target:    {result.sync_map.target}",
         f"  Board:     {result.sync_map.board_url}",
         "",
-        f"  Created:   {created_epics} epic(s), {created_stories} story(s), {created_tasks} task(s)",
+        "  Items:     {} total ({})".format(
+            total_items,
+            _type_breakdown(
+                total_by_type[PlanItemType.EPIC],
+                total_by_type[PlanItemType.STORY],
+                total_by_type[PlanItemType.TASK],
+            ),
+        ),
     ]
 
-    if any(count > 0 for count in (existing_epics, existing_stories, existing_tasks)):
-        lines.append(f"  Existing:  {existing_epics} epic(s), {existing_stories} story(s), {existing_tasks} task(s)")
-
-    lines.append("")
-
-    label_map = {
-        PlanItemType.EPIC: "Epic",
-        PlanItemType.STORY: "Story",
-        PlanItemType.TASK: "Task",
-    }
-    for item_type in (PlanItemType.EPIC, PlanItemType.STORY, PlanItemType.TASK):
-        for item_id in sorted(result.sync_map.entries):
-            entry = result.sync_map.entries[item_id]
-            if entry.item_type != item_type:
-                continue
-            lines.append(f"  {label_map[item_type]:<5}  {item_id:<6}  {entry.key:<6}  {entry.url}")
+    if total_created > 0:
+        lines.append(f"  Created:   {total_created} ({_type_breakdown(created_epics, created_stories, created_tasks)})")
+    if total_matched > 0:
+        lines.append(f"  Matched:   {total_matched} ({_type_breakdown(matched_epics, matched_stories, matched_tasks)})")
+    if total_created == 0:
+        lines.append("  Status:    all items up to date")
 
     lines.append("")
     sync_map_path = f"{config.sync_path}.dry-run" if result.dry_run else str(config.sync_path)
@@ -303,6 +381,43 @@ def _format_summary(result: SyncResult, config: PlanPilotConfig) -> str:
     return "\n".join(lines)
 
 
+async def _run_clean(args: argparse.Namespace) -> CleanResult:
+    config = load_config(args.config)
+    all_plans: bool = getattr(args, "all", False)
+
+    if not args.verbose:
+        from planpilot.progress import RichSyncProgress
+
+        with RichSyncProgress() as progress:
+            pp = await PlanPilot.from_config(config, progress=progress)
+            result = await pp.clean(dry_run=args.dry_run, all_plans=all_plans)
+    else:
+        pp = await PlanPilot.from_config(config)
+        result = await pp.clean(dry_run=args.dry_run, all_plans=all_plans)
+
+    print(_format_clean_summary(result))
+    return result
+
+
+def _format_clean_summary(result: CleanResult) -> str:
+    mode = "dry-run" if result.dry_run else "apply"
+
+    lines = [
+        "",
+        f"planpilot - clean complete ({mode})",
+        "",
+        f"  Plan ID:    {result.plan_id}",
+        f"  Deleted:    {result.items_deleted} issue{'s' if result.items_deleted != 1 else ''}",
+        "",
+    ]
+
+    if result.dry_run:
+        lines.append("  [dry-run] No issues were deleted")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
 def _format_map_sync_summary(result: MapSyncResult, config: PlanPilotConfig) -> str:
     mode = "dry-run" if result.dry_run else "apply"
 
@@ -434,8 +549,15 @@ def _run_init_interactive(output: Path) -> int:
 
         owner_type: str | None = None
         if provider == "github":
-            resolved_token = _resolve_init_token(auth=auth, target=target, static_token=auth_token)
-            owner_type = _validate_github_auth_for_init(token=resolved_token, target=target)
+            if sys.stderr.isatty():
+                from planpilot.progress import RichSyncProgress
+
+                with RichSyncProgress() as progress:
+                    resolved_token = _resolve_init_token(auth=auth, target=target, static_token=auth_token)
+                    owner_type = _validate_github_auth_for_init(token=resolved_token, target=target, progress=progress)
+            else:
+                resolved_token = _resolve_init_token(auth=auth, target=target, static_token=auth_token)
+                owner_type = _validate_github_auth_for_init(token=resolved_token, target=target)
 
         # --- 4. Board URL ---
         default_board_url = _default_board_url_with_owner_type(target, owner_type)
@@ -623,7 +745,10 @@ def main(argv: list[str] | None = None) -> int:
         logging.basicConfig(level=logging.DEBUG, format="%(name)s %(message)s", stream=sys.stderr)
 
     try:
-        asyncio.run(_run_sync(args))
+        if args.command == "sync":
+            asyncio.run(_run_sync(args))
+        elif args.command == "clean":
+            asyncio.run(_run_clean(args))
         return 0
     except (ConfigError, PlanLoadError, PlanValidationError) as exc:
         print(f"error: {exc}", file=sys.stderr)

{planpilot-2.2.0 → planpilot-2.3.0}/src/planpilot/contracts/sync.py

@@ -28,6 +28,12 @@ class SyncResult(BaseModel):
     dry_run: bool = False
 
 
+class CleanResult(BaseModel):
+    plan_id: str
+    items_deleted: int
+    dry_run: bool = False
+
+
 class MapSyncResult(BaseModel):
     sync_map: SyncMap
     added: list[str] = Field(default_factory=list)

{planpilot-2.2.0 → planpilot-2.3.0}/src/planpilot/engine/engine.py

@@ -44,14 +44,19 @@ class SyncEngine:
 
         existing_map = await self._discover(plan_id)
         item_objects: dict[str, Item] = {}
+        plan_type_by_id = {item.id: item.type for item in plan.items}
         for item_id, existing_item in existing_map.items():
-            sync_map.entries[item_id] = to_sync_entry(existing_item)
+            entry = to_sync_entry(existing_item)
+            entry.item_type = plan_type_by_id.get(item_id, entry.item_type)
+            sync_map.entries[item_id] = entry
             item_objects[item_id] = existing_item
 
         try:
-            await self._upsert(plan, plan_id, existing_map, sync_map, item_objects, items_created)
-            await self._enrich(plan, plan_id, sync_map, item_objects)
-            await self._set_relations(plan, item_objects)
+            created_ids: set[str] = set()
+            updated_ids: set[str] = set()
+            await self._upsert(plan, plan_id, existing_map, sync_map, item_objects, items_created, created_ids)
+            await self._enrich(plan, plan_id, sync_map, item_objects, updated_ids)
+            await self._set_relations(plan, item_objects, created_ids, updated_ids)
         except* (SyncError, ProviderError) as error_group:
             first_error = error_group.exceptions[0]
             raise first_error from error_group
@@ -88,6 +93,7 @@ class SyncEngine:
         sync_map: SyncMap,
         item_objects: dict[str, Item],
         items_created: dict[PlanItemType, int],
+        created_ids: set[str],
     ) -> None:
         self._progress.phase_start("Create", total=len(plan.items))
         try:
@@ -104,6 +110,7 @@ class SyncEngine:
                                 sync_map,
                                 item_objects,
                                 items_created,
+                                created_ids,
                             )
                         )
             self._progress.phase_done("Create")
@@ -120,10 +127,13 @@ class SyncEngine:
         sync_map: SyncMap,
         item_objects: dict[str, Item],
         items_created: dict[PlanItemType, int],
+        created_ids: set[str],
     ) -> None:
         if plan_item.id in existing_map:
             existing = existing_map[plan_item.id]
-            sync_map.entries[plan_item.id] = to_sync_entry(existing)
+            entry = to_sync_entry(existing)
+            entry.item_type = plan_item.type
+            sync_map.entries[plan_item.id] = entry
             item_objects[plan_item.id] = existing
             self._progress.item_done("Create")
             return
@@ -146,6 +156,7 @@ class SyncEngine:
         sync_map.entries[plan_item.id] = to_sync_entry(created_item)
         item_objects[plan_item.id] = created_item
         items_created[plan_item.type] += 1
+        created_ids.add(plan_item.id)
         self._progress.item_done("Create")
 
     async def _enrich(
@@ -154,12 +165,13 @@ class SyncEngine:
         plan_id: str,
         sync_map: SyncMap,
         item_objects: dict[str, Item],
+        updated_ids: set[str] | None = None,
     ) -> None:
         self._progress.phase_start("Enrich", total=len(plan.items))
         try:
             async with asyncio.TaskGroup() as tg:
                 for plan_item in plan.items:
-                    tg.create_task(self._enrich_item(plan, plan_item, plan_id, sync_map, item_objects))
+                    tg.create_task(self._enrich_item(plan, plan_item, plan_id, sync_map, item_objects, updated_ids))
             self._progress.phase_done("Enrich")
         except BaseException as exc:
             self._progress.phase_error("Enrich", exc)
@@ -172,6 +184,7 @@ class SyncEngine:
         plan_id: str,
         sync_map: SyncMap,
         item_objects: dict[str, Item],
+        updated_ids: set[str] | None = None,
     ) -> None:
         entry = sync_map.entries.get(plan_item.id)
         if entry is None:
@@ -180,19 +193,51 @@ class SyncEngine:
 
         context = self._build_context(plan, plan_item, plan_id, sync_map)
         body = self._renderer.render(plan_item, context)
+        desired_labels = [self._config.label]
+        desired_size = plan_item.estimate.tshirt if plan_item.estimate is not None else None
+
+        existing_item = item_objects.get(plan_item.id)
+        labels_match = True
+        size_match = True
+        if existing_item is not None:
+            existing_labels = getattr(existing_item, "labels", None)
+            existing_size = getattr(existing_item, "size", None)
+            if existing_labels is not None:
+                labels_match = set(existing_labels) == set(desired_labels)
+            if existing_size is not None:
+                size_match = existing_size == desired_size
+        if (
+            existing_item is not None
+            and existing_item.title == plan_item.title
+            and existing_item.body.strip() == body.strip()
+            and existing_item.item_type == plan_item.type
+            and labels_match
+            and size_match
+        ):
+            self._progress.item_done("Enrich")
+            return
+
         update_input = UpdateItemInput(
             title=plan_item.title,
             body=body,
             item_type=plan_item.type,
-            labels=[self._config.label],
-            size=plan_item.estimate.tshirt if plan_item.estimate is not None else None,
+            labels=desired_labels,
+            size=desired_size,
         )
 
         updated_item = await self._guarded(self._provider.update_item(entry.id, update_input))
         item_objects[plan_item.id] = updated_item
+        if updated_ids is not None:
+            updated_ids.add(plan_item.id)
         self._progress.item_done("Enrich")
 
-    async def _set_relations(self, plan: Plan, item_objects: dict[str, Item]) -> None:
+    async def _set_relations(
+        self,
+        plan: Plan,
+        item_objects: dict[str, Item],
+        created_ids: set[str],
+        updated_ids: set[str] | None = None,
+    ) -> None:
         by_id = {item.id: item for item in plan.items}
         plan_ids = set(by_id)
         parent_pairs: set[tuple[str, str]] = set()
@@ -249,6 +294,14 @@ class SyncEngine:
             if child_parent in item_objects and blocker_parent in item_objects and child_parent != blocker_parent:
                 dependency_pairs.add((child_parent, blocker_parent))
 
+        # Skip relation pairs where both sides are untouched in this run.
+        # If nothing was touched (e.g., custom renderer omits relation context),
+        # keep all pairs so relation-only updates still apply.
+        touched_ids = created_ids.union(updated_ids or set())
+        if touched_ids:
+            parent_pairs = {(c, p) for c, p in parent_pairs if c in touched_ids or p in touched_ids}
+            dependency_pairs = {(b, k) for b, k in dependency_pairs if b in touched_ids or k in touched_ids}
+
         total_relations = len(parent_pairs) + len(dependency_pairs)
         self._progress.phase_start("Relations", total=total_relations)
         try:

{planpilot-2.2.0 → planpilot-2.3.0}/src/planpilot/providers/github/github_gql/__init__.py

@@ -31,6 +31,7 @@ from .create_label import (
     CreateLabelCreateLabel,
     CreateLabelCreateLabelLabel,
 )
+from .delete_issue import DeleteIssue, DeleteIssueDeleteIssue
 from .enums import IssueClosedStateReason, ProjectV2FieldType
 from .exceptions import (
     GraphQLClientError,
@@ -104,6 +105,7 @@ from .operations import (
     CLOSE_ISSUE_GQL,
     CREATE_ISSUE_GQL,
     CREATE_LABEL_GQL,
+    DELETE_ISSUE_GQL,
     FETCH_ORG_PROJECT_GQL,
     FETCH_PROJECT_FIELDS_GQL,
     FETCH_PROJECT_ITEMS_GQL,
@@ -160,23 +162,6 @@ __all__ = [
     "ADD_LABELS_GQL",
     "ADD_PROJECT_ITEM_GQL",
     "ADD_SUB_ISSUE_GQL",
-    "CLOSE_ISSUE_GQL",
-    "CREATE_ISSUE_GQL",
-    "CREATE_LABEL_GQL",
-    "FETCH_ORG_PROJECT_GQL",
-    "FETCH_PROJECT_FIELDS_GQL",
-    "FETCH_PROJECT_ITEMS_GQL",
-    "FETCH_RELATIONS_GQL",
-    "FETCH_REPO_GQL",
-    "FETCH_USER_PROJECT_GQL",
-    "FIND_LABELS_GQL",
-    "GET_ISSUE_GQL",
-    "REMOVE_BLOCKED_BY_GQL",
-    "REMOVE_LABELS_GQL",
-    "REMOVE_SUB_ISSUE_GQL",
-    "SEARCH_ISSUES_GQL",
-    "UPDATE_ISSUE_GQL",
-    "UPDATE_PROJECT_FIELD_GQL",
     "AddBlockedBy",
     "AddBlockedByAddBlockedBy",
     "AddBlockedByAddBlockedByIssue",
@@ -191,6 +176,9 @@ __all__ = [
     "AddSubIssueAddSubIssueSubIssue",
     "AsyncBaseClient",
     "BaseModel",
+    "CLOSE_ISSUE_GQL",
+    "CREATE_ISSUE_GQL",
+    "CREATE_LABEL_GQL",
     "CloseIssue",
     "CloseIssueCloseIssue",
     "CloseIssueCloseIssueIssue",
@@ -200,6 +188,16 @@ __all__ = [
     "CreateLabel",
     "CreateLabelCreateLabel",
     "CreateLabelCreateLabelLabel",
+    "DELETE_ISSUE_GQL",
+    "DeleteIssue",
+    "DeleteIssueDeleteIssue",
+    "FETCH_ORG_PROJECT_GQL",
+    "FETCH_PROJECT_FIELDS_GQL",
+    "FETCH_PROJECT_ITEMS_GQL",
+    "FETCH_RELATIONS_GQL",
+    "FETCH_REPO_GQL",
+    "FETCH_USER_PROJECT_GQL",
+    "FIND_LABELS_GQL",
     "FetchOrgProject",
     "FetchOrgProjectOrganization",
     "FetchOrgProjectOrganizationProjectV2",
@@ -241,6 +239,7 @@ __all__ = [
     "FindLabelsRepository",
     "FindLabelsRepositoryLabels",
     "FindLabelsRepositoryLabelsNodes",
+    "GET_ISSUE_GQL",
     "GetIssue",
     "GetIssueNodeIssue",
     "GetIssueNodeNode",
@@ -255,6 +254,9 @@ __all__ = [
     "IssueCoreLabels",
     "IssueCoreLabelsNodes",
     "ProjectV2FieldType",
+    "REMOVE_BLOCKED_BY_GQL",
+    "REMOVE_LABELS_GQL",
+    "REMOVE_SUB_ISSUE_GQL",
     "RemoveBlockedBy",
     "RemoveBlockedByRemoveBlockedBy",
     "RemoveBlockedByRemoveBlockedByIssue",
@@ -264,6 +266,7 @@ __all__ = [
     "RemoveSubIssueRemoveSubIssue",
     "RemoveSubIssueRemoveSubIssueIssue",
     "RemoveSubIssueRemoveSubIssueSubIssue",
+    "SEARCH_ISSUES_GQL",
     "SearchIssues",
     "SearchIssuesSearch",
     "SearchIssuesSearchNodesApp",
@@ -275,6 +278,8 @@ __all__ = [
     "SearchIssuesSearchNodesRepository",
     "SearchIssuesSearchNodesUser",
     "SearchIssuesSearchPageInfo",
+    "UPDATE_ISSUE_GQL",
+    "UPDATE_PROJECT_FIELD_GQL",
     "UpdateIssue",
     "UpdateIssueUpdateIssue",
     "UpdateIssueUpdateIssueIssue",