github-issue-list 0.0.1__tar.gz

github_issue_list-0.0.1/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: github-issue-list
+Version: 0.0.1
+Summary: List open GitHub issues assigned to a user in an organization.
+Author: Kaizten Analytics
+License-Expression: LicenseRef-Proprietary
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# GitHub Issue List
+
+`github-issue-list` uses the authenticated GitHub CLI account to list open issues assigned to a user in an organization's non-archived repositories.
+
+Issues are printed in a table sorted globally from the oldest creation time to the most recent. Issue titles are normalized to one line and limited to 30 characters.
+
+## Requirements
+
+- Python 3.10 or newer
+- GitHub CLI (`gh`)
+- An authenticated GitHub CLI session:
+
+```bash
+gh auth login
+```
+
+## Usage
+
+After installing the package, run:
+
+```bash
+github-issue-list
+```
+
+The organization defaults to `kaizten`, and the username defaults to the active `gh` account. Override either value with named arguments:
+
+```bash
+github-issue-list --organization octo --username monalisa
+```
+
+From a source checkout, the wrapper exposes the same interface:
+
+```bash
+./github-issue-list.py --organization octo --username monalisa
+```
+
+```text
+usage: github-issue-list [-h] [--organization ORGANIZATION] [--username USERNAME]
+
+List open GitHub issues assigned to a user in an organization.
+
+options:
+  -h, --help            show this help message and exit
+  --organization ORGANIZATION
+                        GitHub organization. Default: kaizten
+  --username USERNAME   GitHub assignee. Defaults to the authenticated gh user.
+```
+
+The table contains the full repository name, issue number, truncated title, UTC creation time, and elapsed time since creation. The search returns at most 1,000 issues, matching GitHub's issue-search result limit.
+
+## Development
+
+Run the unit tests:
+
+```bash
+python3 -m unittest discover -s tests -v
+```
+
+Build and validate the wheel and source distribution:
+
+```bash
+./build-package.sh
+```
+
+Artifacts are written under `dist/` and checked with Twine.
+
+Publish previously built artifacts to PyPI:
+
+```bash
+./publish-pypi.sh
+```
+
+If PyPI reports that the version already exists, increment the version in `pyproject.toml`, rebuild, and publish again.
+
+Install the package in a virtual environment:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install .
+```

github_issue_list-0.0.1/README.md

@@ -0,0 +1,81 @@
+# GitHub Issue List
+
+`github-issue-list` uses the authenticated GitHub CLI account to list open issues assigned to a user in an organization's non-archived repositories.
+
+Issues are printed in a table sorted globally from the oldest creation time to the most recent. Issue titles are normalized to one line and limited to 30 characters.
+
+## Requirements
+
+- Python 3.10 or newer
+- GitHub CLI (`gh`)
+- An authenticated GitHub CLI session:
+
+```bash
+gh auth login
+```
+
+## Usage
+
+After installing the package, run:
+
+```bash
+github-issue-list
+```
+
+The organization defaults to `kaizten`, and the username defaults to the active `gh` account. Override either value with named arguments:
+
+```bash
+github-issue-list --organization octo --username monalisa
+```
+
+From a source checkout, the wrapper exposes the same interface:
+
+```bash
+./github-issue-list.py --organization octo --username monalisa
+```
+
+```text
+usage: github-issue-list [-h] [--organization ORGANIZATION] [--username USERNAME]
+
+List open GitHub issues assigned to a user in an organization.
+
+options:
+  -h, --help            show this help message and exit
+  --organization ORGANIZATION
+                        GitHub organization. Default: kaizten
+  --username USERNAME   GitHub assignee. Defaults to the authenticated gh user.
+```
+
+The table contains the full repository name, issue number, truncated title, UTC creation time, and elapsed time since creation. The search returns at most 1,000 issues, matching GitHub's issue-search result limit.
+
+## Development
+
+Run the unit tests:
+
+```bash
+python3 -m unittest discover -s tests -v
+```
+
+Build and validate the wheel and source distribution:
+
+```bash
+./build-package.sh
+```
+
+Artifacts are written under `dist/` and checked with Twine.
+
+Publish previously built artifacts to PyPI:
+
+```bash
+./publish-pypi.sh
+```
+
+If PyPI reports that the version already exists, increment the version in `pyproject.toml`, rebuild, and publish again.
+
+Install the package in a virtual environment:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install .
+```

github_issue_list-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "github-issue-list"
+version = "0.0.1"
+description = "List open GitHub issues assigned to a user in an organization."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "LicenseRef-Proprietary"
+authors = [{ name = "Kaizten Analytics" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+]
+
+[project.scripts]
+github-issue-list = "github_issue_list:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+py-modules = ["github_issue_list"]

github_issue_list-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

github_issue_list-0.0.1/src/github_issue_list.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: github-issue-list
+Version: 0.0.1
+Summary: List open GitHub issues assigned to a user in an organization.
+Author: Kaizten Analytics
+License-Expression: LicenseRef-Proprietary
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# GitHub Issue List
+
+`github-issue-list` uses the authenticated GitHub CLI account to list open issues assigned to a user in an organization's non-archived repositories.
+
+Issues are printed in a table sorted globally from the oldest creation time to the most recent. Issue titles are normalized to one line and limited to 30 characters.
+
+## Requirements
+
+- Python 3.10 or newer
+- GitHub CLI (`gh`)
+- An authenticated GitHub CLI session:
+
+```bash
+gh auth login
+```
+
+## Usage
+
+After installing the package, run:
+
+```bash
+github-issue-list
+```
+
+The organization defaults to `kaizten`, and the username defaults to the active `gh` account. Override either value with named arguments:
+
+```bash
+github-issue-list --organization octo --username monalisa
+```
+
+From a source checkout, the wrapper exposes the same interface:
+
+```bash
+./github-issue-list.py --organization octo --username monalisa
+```
+
+```text
+usage: github-issue-list [-h] [--organization ORGANIZATION] [--username USERNAME]
+
+List open GitHub issues assigned to a user in an organization.
+
+options:
+  -h, --help            show this help message and exit
+  --organization ORGANIZATION
+                        GitHub organization. Default: kaizten
+  --username USERNAME   GitHub assignee. Defaults to the authenticated gh user.
+```
+
+The table contains the full repository name, issue number, truncated title, UTC creation time, and elapsed time since creation. The search returns at most 1,000 issues, matching GitHub's issue-search result limit.
+
+## Development
+
+Run the unit tests:
+
+```bash
+python3 -m unittest discover -s tests -v
+```
+
+Build and validate the wheel and source distribution:
+
+```bash
+./build-package.sh
+```
+
+Artifacts are written under `dist/` and checked with Twine.
+
+Publish previously built artifacts to PyPI:
+
+```bash
+./publish-pypi.sh
+```
+
+If PyPI reports that the version already exists, increment the version in `pyproject.toml`, rebuild, and publish again.
+
+Install the package in a virtual environment:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install .
+```

github_issue_list-0.0.1/src/github_issue_list.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/github_issue_list.py
+src/github_issue_list.egg-info/PKG-INFO
+src/github_issue_list.egg-info/SOURCES.txt
+src/github_issue_list.egg-info/dependency_links.txt
+src/github_issue_list.egg-info/entry_points.txt
+src/github_issue_list.egg-info/top_level.txt
+tests/test_github_issue_list.py

github_issue_list-0.0.1/src/github_issue_list.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

github_issue_list-0.0.1/src/github_issue_list.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+github-issue-list = github_issue_list:main

github_issue_list-0.0.1/src/github_issue_list.egg-info/top_level.txt

@@ -0,0 +1 @@
+github_issue_list

github_issue_list-0.0.1/src/github_issue_list.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""List open GitHub issues assigned to a user in an organization."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+
+DEFAULT_ORGANIZATION = "kaizten"
+SEARCH_LIMIT = 1000
+TITLE_LIMIT = 30
+NAME_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
+REPOSITORY_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
+
+
+class IssueListError(Exception):
+    """Expected user-facing error."""
+
+
+@dataclass(frozen=True)
+class Issue:
+    repository: str
+    number: int
+    title: str
+    created_at: datetime
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc).replace(microsecond=0)
+
+
+def parse_github_datetime(value: str) -> datetime:
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise IssueListError(f"Invalid GitHub datetime: {value}") from exc
+    if parsed.tzinfo is None:
+        raise IssueListError(f"Invalid GitHub datetime: {value}")
+    return parsed.astimezone(timezone.utc)
+
+
+def format_github_datetime(value: datetime) -> str:
+    return value.astimezone(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def elapsed_time(created_at: datetime, now: datetime) -> str:
+    seconds = max(0, int((now - created_at).total_seconds()))
+    days, seconds = divmod(seconds, 24 * 60 * 60)
+    hours, seconds = divmod(seconds, 60 * 60)
+    minutes = seconds // 60
+    return f"{days}d {hours}h {minutes}m"
+
+
+def validate_name(value: str, label: str) -> str:
+    if not NAME_RE.fullmatch(value):
+        raise IssueListError(f"{label} must contain only letters, numbers, underscores, dots, or hyphens.")
+    return value
+
+
+def validate_repository(value: str) -> str:
+    if not REPOSITORY_RE.fullmatch(value):
+        raise IssueListError(f"Invalid repository name returned by GitHub: {value}")
+    return value
+
+
+def require_gh() -> None:
+    if shutil.which("gh") is None:
+        raise IssueListError("GitHub CLI 'gh' is required but was not found. Install it from https://cli.github.com/.")
+    result = subprocess.run(
+        ["gh", "auth", "status"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise IssueListError("GitHub CLI is not authenticated. Run: gh auth login")
+
+
+def run_gh_json(args: list[str]) -> Any:
+    result = subprocess.run(["gh", *args], capture_output=True, text=True)
+    if result.returncode != 0:
+        details = result.stderr.strip() or result.stdout.strip() or f"exit code {result.returncode}"
+        raise IssueListError(f"gh command failed: gh {' '.join(args)}\n{details}")
+    try:
+        return json.loads(result.stdout or "null")
+    except json.JSONDecodeError as exc:
+        raise IssueListError(f"gh returned invalid JSON for: gh {' '.join(args)}") from exc
+
+
+def current_username() -> str:
+    user = run_gh_json(["api", "user"])
+    if not isinstance(user, dict) or not isinstance(user.get("login"), str):
+        raise IssueListError("Unable to read authenticated GitHub username.")
+    return validate_name(user["login"], "GitHub username")
+
+
+def repository_name(value: Any) -> str:
+    if isinstance(value, str):
+        return validate_repository(value)
+    if isinstance(value, dict) and isinstance(value.get("nameWithOwner"), str):
+        return validate_repository(value["nameWithOwner"])
+    raise IssueListError("GitHub returned an issue without a valid repository name.")
+
+
+def normalize_issue(value: Any) -> Issue | None:
+    if not isinstance(value, dict):
+        raise IssueListError("GitHub returned an invalid issue entry.")
+    if value.get("isPullRequest"):
+        return None
+
+    number = value.get("number")
+    title = value.get("title")
+    created_at = value.get("createdAt")
+    if not isinstance(number, int) or isinstance(number, bool):
+        raise IssueListError("GitHub returned an issue without a numeric issue number.")
+    if not isinstance(title, str):
+        raise IssueListError(f"GitHub returned issue #{number} without a valid title.")
+    if not isinstance(created_at, str):
+        raise IssueListError(f"GitHub returned issue #{number} without a valid creation time.")
+
+    return Issue(
+        repository=repository_name(value.get("repository")),
+        number=number,
+        title=title,
+        created_at=parse_github_datetime(created_at),
+    )
+
+
+def fetch_issues(organization: str, username: str) -> list[Issue]:
+    data = run_gh_json(
+        [
+            "search",
+            "issues",
+            "--owner",
+            organization,
+            "--assignee",
+            username,
+            "--state",
+            "open",
+            "--archived=false",
+            "--sort",
+            "created",
+            "--order",
+            "asc",
+            "--limit",
+            str(SEARCH_LIMIT),
+            "--json",
+            "repository,number,title,createdAt,isPullRequest",
+        ]
+    )
+    if not isinstance(data, list):
+        raise IssueListError("Unexpected issue search response from gh.")
+
+    issues = []
+    for value in data:
+        issue = normalize_issue(value)
+        if issue is not None:
+            issues.append(issue)
+    return sorted(issues, key=lambda issue: (issue.created_at, issue.repository, issue.number))
+
+
+def truncate_title(title: str, limit: int = TITLE_LIMIT) -> str:
+    clean = " ".join(title.split())
+    if len(clean) <= limit:
+        return clean
+    if limit <= 3:
+        return clean[:limit]
+    return clean[: limit - 3] + "..."
+
+
+def table(headers: list[str], rows: list[list[str]]) -> str:
+    widths = [len(header) for header in headers]
+    for row in rows:
+        for index, cell in enumerate(row):
+            widths[index] = max(widths[index], len(cell))
+
+    separator = ["-" * width for width in widths]
+    lines = [
+        "| " + " | ".join(header.ljust(widths[index]) for index, header in enumerate(headers)) + " |",
+        "| " + " | ".join(separator[index] for index in range(len(headers))) + " |",
+    ]
+    for row in rows:
+        lines.append("| " + " | ".join(cell.ljust(widths[index]) for index, cell in enumerate(row)) + " |")
+    return "\n".join(lines)
+
+
+def render_issue_table(issues: list[Issue], now: datetime) -> str:
+    if not issues:
+        return "(none found)"
+    rows = [
+        [
+            issue.repository,
+            f"#{issue.number}",
+            truncate_title(issue.title),
+            format_github_datetime(issue.created_at),
+            elapsed_time(issue.created_at, now),
+        ]
+        for issue in issues
+    ]
+    return table(
+        ["Repository", "Issue number", "Issue title", "Creation time", "Time since creation"],
+        rows,
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="List open GitHub issues assigned to a user in an organization.")
+    parser.add_argument(
+        "--organization",
+        default=DEFAULT_ORGANIZATION,
+        help=f"GitHub organization. Default: {DEFAULT_ORGANIZATION}",
+    )
+    parser.add_argument("--username", help="GitHub assignee. Defaults to the authenticated gh user.")
+    return parser
+
+
+def run(argv: list[str]) -> int:
+    args = build_parser().parse_args(argv)
+    organization = validate_name(args.organization, "Organization")
+    require_gh()
+    username = validate_name(args.username, "Username") if args.username else current_username()
+    print(render_issue_table(fetch_issues(organization, username), utc_now()))
+    return 0
+
+
+def main() -> int:
+    try:
+        return run(sys.argv[1:])
+    except IssueListError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+    except OSError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

github_issue_list-0.0.1/tests/test_github_issue_list.py

@@ -0,0 +1,181 @@
+import importlib.util
+import io
+import subprocess
+import sys
+import unittest
+from contextlib import redirect_stderr, redirect_stdout
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import patch
+
+
+MODULE_PATH = Path(__file__).parents[1] / "src" / "github_issue_list.py"
+PYPROJECT_PATH = Path(__file__).parents[1] / "pyproject.toml"
+SPEC = importlib.util.spec_from_file_location("github_issue_list", MODULE_PATH)
+issue_list = importlib.util.module_from_spec(SPEC)
+assert SPEC.loader is not None
+sys.modules[SPEC.name] = issue_list
+SPEC.loader.exec_module(issue_list)
+
+
+class GithubIssueListTests(unittest.TestCase):
+    def test_pyproject_installs_command_line_entry_point(self):
+        try:
+            import tomllib
+        except ModuleNotFoundError:  # pragma: no cover - Python 3.10 fallback.
+            self.skipTest("tomllib is not available")
+
+        metadata = tomllib.loads(PYPROJECT_PATH.read_text(encoding="utf-8"))
+
+        self.assertEqual(metadata["project"]["scripts"]["github-issue-list"], "github_issue_list:main")
+
+    def test_parser_defaults_and_named_arguments(self):
+        defaults = issue_list.build_parser().parse_args([])
+        selected = issue_list.build_parser().parse_args(["--organization", "octo", "--username", "monalisa"])
+
+        self.assertEqual(defaults.organization, "kaizten")
+        self.assertIsNone(defaults.username)
+        self.assertEqual(selected.organization, "octo")
+        self.assertEqual(selected.username, "monalisa")
+
+    def test_parser_rejects_positional_arguments(self):
+        with redirect_stderr(io.StringIO()):
+            with self.assertRaises(SystemExit):
+                issue_list.build_parser().parse_args(["octo"])
+
+    def test_validate_name_rejects_invalid_value(self):
+        with self.assertRaises(issue_list.IssueListError):
+            issue_list.validate_name("bad/name", "Organization")
+
+    def test_current_username_uses_authenticated_user(self):
+        with patch.object(issue_list, "run_gh_json", return_value={"login": "monalisa"}) as run_gh:
+            self.assertEqual(issue_list.current_username(), "monalisa")
+        run_gh.assert_called_once_with(["api", "user"])
+
+    def test_require_gh_rejects_missing_or_unauthenticated_cli(self):
+        with patch.object(issue_list.shutil, "which", return_value=None):
+            with self.assertRaisesRegex(issue_list.IssueListError, "required"):
+                issue_list.require_gh()
+
+        result = subprocess.CompletedProcess(["gh", "auth", "status"], 1)
+        with patch.object(issue_list.shutil, "which", return_value="/usr/bin/gh"), patch.object(
+            issue_list.subprocess, "run", return_value=result
+        ):
+            with self.assertRaisesRegex(issue_list.IssueListError, "not authenticated"):
+                issue_list.require_gh()
+
+    def test_run_gh_json_reports_command_and_json_errors(self):
+        failed = subprocess.CompletedProcess(["gh"], 1, stdout="", stderr="failure")
+        with patch.object(issue_list.subprocess, "run", return_value=failed):
+            with self.assertRaisesRegex(issue_list.IssueListError, "failure"):
+                issue_list.run_gh_json(["api", "user"])
+
+        malformed = subprocess.CompletedProcess(["gh"], 0, stdout="not-json", stderr="")
+        with patch.object(issue_list.subprocess, "run", return_value=malformed):
+            with self.assertRaisesRegex(issue_list.IssueListError, "invalid JSON"):
+                issue_list.run_gh_json(["api", "user"])
+
+    def test_fetch_issues_uses_expected_search_and_sorts_globally(self):
+        response = [
+            {
+                "repository": {"nameWithOwner": "octo/zeta"},
+                "number": 9,
+                "title": "newer",
+                "createdAt": "2026-10-14T10:00:00Z",
+                "isPullRequest": False,
+            },
+            {
+                "repository": {"nameWithOwner": "octo/alpha"},
+                "number": 2,
+                "title": "oldest",
+                "createdAt": "2026-10-12T10:00:00Z",
+                "isPullRequest": False,
+            },
+            {
+                "repository": {"nameWithOwner": "octo/alpha"},
+                "number": 1,
+                "title": "same time",
+                "createdAt": "2026-10-14T10:00:00Z",
+                "isPullRequest": False,
+            },
+            {
+                "repository": {"nameWithOwner": "octo/alpha"},
+                "number": 3,
+                "title": "pull request",
+                "createdAt": "2026-10-11T10:00:00Z",
+                "isPullRequest": True,
+            },
+        ]
+        with patch.object(issue_list, "run_gh_json", return_value=response) as run_gh:
+            issues = issue_list.fetch_issues("octo", "monalisa")
+
+        self.assertEqual([(item.repository, item.number) for item in issues], [("octo/alpha", 2), ("octo/alpha", 1), ("octo/zeta", 9)])
+        args = run_gh.call_args.args[0]
+        self.assertEqual(args[:2], ["search", "issues"])
+        self.assertIn("--owner", args)
+        self.assertEqual(args[args.index("--owner") + 1], "octo")
+        self.assertEqual(args[args.index("--assignee") + 1], "monalisa")
+        self.assertEqual(args[args.index("--state") + 1], "open")
+        self.assertIn("--archived=false", args)
+        self.assertEqual(args[args.index("--sort") + 1], "created")
+        self.assertEqual(args[args.index("--order") + 1], "asc")
+
+    def test_truncate_title_normalizes_whitespace_and_limits_length(self):
+        self.assertEqual(issue_list.truncate_title("multi\nline\t title"), "multi line title")
+        self.assertEqual(issue_list.truncate_title("x" * 31), ("x" * 27) + "...")
+        self.assertEqual(len(issue_list.truncate_title("x" * 31)), 30)
+
+    def test_datetime_and_elapsed_time(self):
+        created = issue_list.parse_github_datetime("2026-10-12T10:30:00Z")
+        now = datetime(2026, 10, 14, 12, 0, tzinfo=timezone.utc)
+
+        self.assertEqual(issue_list.format_github_datetime(created), "2026-10-12T10:30:00Z")
+        self.assertEqual(issue_list.elapsed_time(created, now), "2d 1h 30m")
+
+    def test_render_issue_table_has_required_columns_and_values(self):
+        created = datetime(2026, 10, 12, 10, 30, tzinfo=timezone.utc)
+        now = datetime(2026, 10, 14, 12, 0, tzinfo=timezone.utc)
+        rendered = issue_list.render_issue_table(
+            [issue_list.Issue("octo/repo", 7, "An issue title", created)],
+            now,
+        )
+
+        self.assertIn("Repository", rendered)
+        self.assertIn("Issue number", rendered)
+        self.assertIn("Issue title", rendered)
+        self.assertIn("Creation time", rendered)
+        self.assertIn("Time since creation", rendered)
+        self.assertIn("octo/repo", rendered)
+        self.assertIn("#7", rendered)
+        self.assertIn("2026-10-12T10:30:00Z", rendered)
+        self.assertIn("2d 1h 30m", rendered)
+        self.assertEqual(issue_list.render_issue_table([], now), "(none found)")
+
+    def test_run_resolves_defaults_and_prints_table(self):
+        now = datetime(2026, 10, 14, 12, 0, tzinfo=timezone.utc)
+        issue = issue_list.Issue("kaizten/tools", 4, "Old issue", datetime(2026, 10, 13, 12, 0, tzinfo=timezone.utc))
+        output = io.StringIO()
+        with patch.object(issue_list, "require_gh"), patch.object(
+            issue_list, "current_username", return_value="cexposit"
+        ), patch.object(issue_list, "fetch_issues", return_value=[issue]) as fetch, patch.object(
+            issue_list, "utc_now", return_value=now
+        ), redirect_stdout(output):
+            result = issue_list.run([])
+
+        self.assertEqual(result, 0)
+        fetch.assert_called_once_with("kaizten", "cexposit")
+        self.assertIn("kaizten/tools", output.getvalue())
+
+    def test_main_returns_one_for_expected_error(self):
+        stderr = io.StringIO()
+        with patch.object(issue_list, "run", side_effect=issue_list.IssueListError("broken")), patch.object(
+            sys, "argv", ["github-issue-list"]
+        ), redirect_stderr(stderr):
+            result = issue_list.main()
+
+        self.assertEqual(result, 1)
+        self.assertEqual(stderr.getvalue(), "Error: broken\n")
+
+
+if __name__ == "__main__":
+    unittest.main()