pygitcode 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

gitcode_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"

gitcode_cli/adapters/issues.py

@@ -177,18 +177,35 @@ class IssueAdapter:
             if not current_login:
                 raise click.ClickException("failed to resolve @me: current user has no login")
             author = current_login
-        items = self.service.list(
-            owner,
-            repo,
-            state=state,
-            labels=_normalize_multi_values(labels),
-            creator=author,
-            assignee=assignee,
-            milestone=milestone,
-            mention=mention,
-            search=search,
-        )
-        if isinstance(items, list) and labels and len(labels) > 1:
+        params = {
+            "state": state,
+            "labels": _normalize_multi_values(labels),
+            "creator": author,
+            "assignee": assignee,
+            "milestone": milestone,
+            "mention": mention,
+            "search": search,
+        }
+        needs_and_filter = bool(labels) and len(labels) > 1
+        per_page = 100 if limit is None else min(limit, 100)
+        items: list[Any] = []
+        page = 1
+        while True:
+            page_items = _as_list(self.service.list(owner, repo, **params, page=page, per_page=per_page))
+            if not page_items:
+                break
+            items.extend(page_items)
+            if len(page_items) < per_page:
+                break
+            if limit is not None:
+                if needs_and_filter:
+                    matched = sum(1 for item in items if _matches_all_labels(item, labels))
+                else:
+                    matched = len(items)
+                if matched >= limit:
+                    break
+            page += 1
+        if needs_and_filter:
             items = [item for item in items if _matches_all_labels(item, labels)]
         if limit is not None:
             return items[:limit]

gitcode_cli/audit.py

@@ -0,0 +1,442 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from .errors import APIError
+from .services import PullRequestService
+
+# Directory/basename patterns are case-insensitive; PascalCase TestX stays sensitive
+# so docs/testing-guide.md and testdata.json are not treated as tests.
+TEST_PATH_RE = re.compile(
+    r"(?i:(^|/)(test|tests|__tests__|spec|__mocks__)/|(^|/)test_|_test\.|\.test\.|\.spec\.|(^|/)test\.cpp)"
+    r"|(^|/)Test[A-Z]"
+)
+
+AUDIT_JSON_FIELDS = [
+    "number",
+    "title",
+    "url",
+    "overall",
+    "verdict",
+    "loc",
+    "r1",
+    "r2",
+    "r3",
+    "r4",
+    "failedRules",
+    "reasons",
+    "rules",
+    "milestone",
+    "issues",
+    "unresolved",
+    "reviewCnt",
+    "hasTest",
+    "hasMinutes",
+]
+
+
+@dataclass(frozen=True)
+class AuditThresholds:
+    th1: int = 100
+    th2: int = 1000
+    minutes_keyword: str = "评审纪要"
+
+
+def _as_list(value: Any) -> list[Any]:
+    if isinstance(value, list):
+        return value
+    return []
+
+
+def _as_text(value: Any) -> str:
+    return value if isinstance(value, str) else ("" if value is None else str(value))
+
+
+def _optional_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _resolve_discussion_passed(pr: dict[str, Any]) -> bool:
+    mergeable_state = pr.get("mergeable_state")
+    if not isinstance(mergeable_state, dict):
+        return True
+    resolve_pass = mergeable_state.get("resolve_discussion_passed", True)
+    if resolve_pass is None:
+        return True
+    return bool(resolve_pass)
+
+
+def _mergeable_state_known(pr: dict[str, Any]) -> bool:
+    mergeable_state = pr.get("mergeable_state")
+    if not isinstance(mergeable_state, dict):
+        return False
+    return mergeable_state.get("resolve_discussion_passed") is not None
+
+
+def loc_from_list_item(item: dict[str, Any] | None) -> int | None:
+    if not item:
+        return None
+    added = item.get("added_lines")
+    removed = item.get("removed_lines")
+    if isinstance(added, int) and isinstance(removed, int):
+        return added + removed
+    return None
+
+
+_DIFF_FILE_HEADER_RE = re.compile(r"^(---|\+\+\+) (?:[ab]/|/dev/null|\")")
+
+
+def loc_from_diff(diff_text: str) -> int:
+    loc = 0
+    skipping_binary = False
+    in_hunk = False
+    for line in diff_text.splitlines():
+        if line.startswith("diff --git "):
+            skipping_binary = False
+            in_hunk = False
+            continue
+        if line.startswith("GIT binary patch"):
+            skipping_binary = True
+            continue
+        if skipping_binary:
+            continue
+        if line.startswith("@@"):
+            in_hunk = True
+            continue
+        if not in_hunk and _DIFF_FILE_HEADER_RE.match(line):
+            continue
+        if line.startswith("+") or line.startswith("-"):
+            loc += 1
+    return loc
+
+
+_DIFF_B_PATH_RE = re.compile(r' (?:b/(\S+)|"b/([^"]+)")$')
+_DIFF_A_PATH_RE = re.compile(r' (?:a/(\S+)|"a/([^"]+)")')
+
+
+def _path_from_diff_header(line: str) -> str | None:
+    if not line.startswith("diff --git "):
+        return None
+    rest = line[len("diff --git") :]
+    match = _DIFF_B_PATH_RE.search(rest) or _DIFF_A_PATH_RE.search(rest)
+    if not match:
+        return None
+    return match.group(1) or match.group(2)
+
+
+def _is_plus_dev_null_header(line: str) -> bool:
+    return line.startswith("+++ /dev/null") or line.startswith('+++ "/dev/null"')
+
+
+def paths_from_diff(diff_text: str) -> list[str]:
+    paths: list[str] = []
+    current: str | None = None
+    deleted = False
+    in_hunk = False
+    seen_minus_header = False
+    for line in diff_text.splitlines():
+        if line.startswith("diff --git "):
+            if current and not deleted:
+                paths.append(current)
+            current = _path_from_diff_header(line)
+            deleted = False
+            in_hunk = False
+            seen_minus_header = False
+            continue
+        if line.startswith("@@"):
+            in_hunk = True
+            continue
+        if line.startswith("deleted file mode"):
+            deleted = True
+            continue
+        if line.startswith("--- "):
+            seen_minus_header = True
+            continue
+        if not in_hunk and seen_minus_header and _is_plus_dev_null_header(line):
+            deleted = True
+    if current and not deleted:
+        paths.append(current)
+    return paths
+
+
+def _current_file_path(item: dict[str, Any]) -> str | None:
+    status = str(item.get("status") or item.get("change_type") or "").lower()
+    if status in {"removed", "deleted", "delete"}:
+        return None
+    patch = item.get("patch")
+    if isinstance(patch, dict):
+        new_path = patch.get("new_path")
+        if new_path and str(new_path) not in {"/dev/null", "dev/null"}:
+            return str(new_path)
+        if patch.get("old_path"):
+            return None
+    filename = item.get("filename")
+    return str(filename) if filename else None
+
+
+def loc_and_paths_from_files(files: list[Any]) -> tuple[int | None, list[str]]:
+    paths: list[str] = []
+    loc = 0
+    have_counts = False
+    for item in files:
+        if not isinstance(item, dict):
+            continue
+        path = _current_file_path(item)
+        if path:
+            paths.append(path)
+        if "additions" not in item and "deletions" not in item:
+            continue
+        additions = _optional_int(item["additions"]) if "additions" in item else None
+        deletions = _optional_int(item["deletions"]) if "deletions" in item else None
+        if additions is None and deletions is None:
+            continue
+        loc += (additions or 0) + (deletions or 0)
+        have_counts = True
+    return (loc if have_counts else None), paths
+
+
+def _label_names(labels: Any) -> list[str]:
+    names: list[str] = []
+    for label in _as_list(labels):
+        if isinstance(label, dict):
+            names.append(str(label.get("name") or ""))
+        elif label is not None:
+            names.append(str(label))
+    return names
+
+
+def _issue_numbers(issues: list[Any]) -> list[str]:
+    numbers: list[str] = []
+    for issue in issues:
+        if not isinstance(issue, dict):
+            continue
+        number = issue.get("number")
+        if number is not None:
+            numbers.append(str(number))
+    return numbers
+
+
+def _milestone_title(milestone: Any) -> str | None:
+    if isinstance(milestone, dict):
+        title = milestone.get("title")
+        return str(title) if title else None
+    return None
+
+
+def evaluate_audit(
+    *,
+    pr: dict[str, Any],
+    issues: list[Any],
+    comments: list[Any],
+    loc: int | None,
+    file_paths: list[str] | None,
+    thresholds: AuditThresholds | None = None,
+) -> dict[str, Any]:
+    thresholds = thresholds or AuditThresholds()
+    keyword = thresholds.minutes_keyword
+
+    issue_numbers = _issue_numbers(issues)
+    milestone = _milestone_title(pr.get("milestone"))
+    r1 = milestone is not None or bool(issue_numbers)
+    r1_reasons: list[str] = []
+    if not r1:
+        r1_reasons.append("R1: no milestone and no officially linked issues")
+
+    unresolved = [
+        comment
+        for comment in comments
+        if isinstance(comment, dict)
+        and comment.get("comment_type") == "diff_comment"
+        and comment.get("resolved") is False
+    ]
+    resolve_pass = _resolve_discussion_passed(pr)
+    r2 = len(unresolved) == 0 and resolve_pass
+    r2_reasons: list[str] = []
+    if not r2:
+        parts: list[str] = []
+        if unresolved:
+            parts.append(f"{len(unresolved)} unresolved diff_comment(s)")
+        if not resolve_pass:
+            parts.append("mergeable_state.resolve_discussion_passed=false")
+        r2_reasons.append("R2: " + "; ".join(parts))
+    elif not _mergeable_state_known(pr):
+        r2_reasons.append("R2: merge state unknown")
+
+    review_cnt = sum(
+        1 for comment in comments if isinstance(comment, dict) and comment.get("comment_type") == "diff_comment"
+    )
+    has_test = None if file_paths is None else any(TEST_PATH_RE.search(_as_text(path)) for path in file_paths)
+    r3_reasons: list[str] = []
+    if loc is None:
+        r3 = False
+        r3_reasons.append("R3: loc unavailable")
+    else:
+        r3 = loc <= thresholds.th1 or review_cnt > 0 or bool(has_test)
+        if not r3:
+            r3_reasons.append(f"R3: loc {loc} > {thresholds.th1}, no diff_comment, and no test-path files")
+
+    has_minutes = (
+        keyword in _as_text(pr.get("body"))
+        or any(keyword in _as_text(comment.get("body") if isinstance(comment, dict) else "") for comment in comments)
+        or any(keyword in name for name in _label_names(pr.get("labels")))
+    )
+    r4_reasons: list[str] = []
+    if loc is None:
+        r4 = False
+        r4_reasons.append("R4: loc unavailable")
+    else:
+        r4 = loc <= thresholds.th2 or has_minutes
+        if not r4:
+            r4_reasons.append(
+                f"R4: loc {loc} > {thresholds.th2}, and '{keyword}' not found in body, comments, or labels"
+            )
+
+    overall = r1 and r2 and r3 and r4
+    reasons = [*r1_reasons, *r2_reasons, *r3_reasons, *r4_reasons]
+    failed_rules = [rule for rule, passed in (("R1", r1), ("R2", r2), ("R3", r3), ("R4", r4)) if not passed]
+    return {
+        "number": pr.get("number"),
+        "title": pr.get("title") or "",
+        "url": pr.get("html_url") or pr.get("url"),
+        "overall": overall,
+        "verdict": "PASS" if overall else "FAIL",
+        "loc": loc,
+        "r1": r1,
+        "r2": r2,
+        "r3": r3,
+        "r4": r4,
+        "failedRules": failed_rules,
+        "reasons": reasons,
+        "rules": {
+            "R1": {"pass": r1, "reasons": r1_reasons},
+            "R2": {"pass": r2, "reasons": r2_reasons},
+            "R3": {"pass": r3, "reasons": r3_reasons},
+            "R4": {"pass": r4, "reasons": r4_reasons},
+        },
+        "milestone": milestone,
+        "issues": issue_numbers,
+        "unresolved": len(unresolved),
+        "reviewCnt": review_cnt,
+        "hasTest": has_test,
+        "hasMinutes": has_minutes,
+    }
+
+
+def audit_error_result(
+    number: int,
+    exc: BaseException,
+    listed: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    listed = listed or {}
+    reason = f"audit error: {exc}"
+    return {
+        "number": listed.get("number", number),
+        "title": listed.get("title") or "",
+        "url": listed.get("html_url") or listed.get("url"),
+        "overall": False,
+        "verdict": "FAIL",
+        "loc": None,
+        "r1": False,
+        "r2": False,
+        "r3": False,
+        "r4": False,
+        "failedRules": ["R1", "R2", "R3", "R4"],
+        "reasons": [reason],
+        "rules": {
+            "R1": {"pass": False, "reasons": [reason]},
+            "R2": {"pass": False, "reasons": [reason]},
+            "R3": {"pass": False, "reasons": [reason]},
+            "R4": {"pass": False, "reasons": [reason]},
+        },
+        "milestone": None,
+        "issues": [],
+        "unresolved": 0,
+        "reviewCnt": 0,
+        "hasTest": None,
+        "hasMinutes": False,
+    }
+
+
+def is_fatal_audit_error(exc: BaseException) -> bool:
+    # HTTP 401 is raised as APIError(..., 401); the client never raises AuthError.
+    return isinstance(exc, APIError) and exc.status_code == 401
+
+
+def resolve_loc_and_paths(
+    service: PullRequestService,
+    owner: str,
+    repo: str,
+    number: int,
+    listed: dict[str, Any] | None,
+    comments: list[Any],
+    thresholds: AuditThresholds,
+    loc_item: dict[str, Any] | None = None,
+) -> tuple[int | None, list[str] | None]:
+    loc = loc_from_list_item(listed)
+    if loc is None:
+        loc = loc_from_list_item(loc_item)
+    paths: list[str] | None = None
+    files_have_counts = False
+    needs_paths = loc is None or (
+        loc > thresholds.th1
+        and not any(isinstance(comment, dict) and comment.get("comment_type") == "diff_comment" for comment in comments)
+    )
+    if loc is None or needs_paths:
+        files = _as_list(service.list_files(owner, repo, number))
+        file_loc, paths = loc_and_paths_from_files(files)
+        files_have_counts = file_loc is not None
+        if loc is None:
+            loc = file_loc
+    if loc is None or (needs_paths and not paths and not files_have_counts):
+        diff_text = service.diff(owner, repo, number)
+        if loc is None:
+            loc = loc_from_diff(diff_text) if diff_text else None
+        if not paths and diff_text:
+            paths = paths_from_diff(diff_text)
+    return loc, paths
+
+
+def audit_pull_request(
+    service: PullRequestService,
+    owner: str,
+    repo: str,
+    number: int,
+    listed: dict[str, Any] | None = None,
+    thresholds: AuditThresholds | None = None,
+) -> dict[str, Any]:
+    thresholds = thresholds or AuditThresholds()
+    detail = service.get(owner, repo, number)
+    if not isinstance(detail, dict):
+        detail = {}
+    if listed:
+        if detail.get("milestone") is None and listed.get("milestone") is not None:
+            detail = {**detail, "milestone": listed.get("milestone")}
+        if not detail.get("labels") and listed.get("labels"):
+            detail = {**detail, "labels": listed.get("labels")}
+        if not detail.get("body") and listed.get("body"):
+            detail = {**detail, "body": listed.get("body")}
+        if detail.get("number") is None:
+            detail = {**detail, "number": listed.get("number")}
+        if not detail.get("title") and listed.get("title"):
+            detail = {**detail, "title": listed.get("title")}
+        if not detail.get("html_url") and not detail.get("url"):
+            detail = {**detail, "html_url": listed.get("html_url") or listed.get("url")}
+
+    issues = _as_list(service.list_issues(owner, repo, number))
+    comments = _as_list(service.list_comments(owner, repo, number))
+    loc, file_paths = resolve_loc_and_paths(service, owner, repo, number, listed, comments, thresholds, loc_item=detail)
+    return evaluate_audit(
+        pr=detail,
+        issues=issues,
+        comments=comments,
+        loc=loc,
+        file_paths=file_paths,
+        thresholds=thresholds,
+    )

gitcode_cli/cli.py

@@ -12,6 +12,7 @@ from .commands.auth import auth_group
 from .commands.compat import compat_group
 from .commands.issue import issue_group
 from .commands.pr import pr_group
+from .commands.setup import setup_group
 from .config import get_token
 from .context import AppContext
 from .errors import GCError
@@ -68,7 +69,7 @@ set_gc_help(
     gc_usage="gc <command> <subcommand> [flags]",
     gc_command_sections=[
         ("CORE COMMANDS", ["auth", "issue", "pr"]),
-        ("ADDITIONAL COMMANDS", ["compat", "completion", "version"]),
+        ("ADDITIONAL COMMANDS", ["compat", "setup", "completion", "version"]),
     ],
     gc_examples=[
         "gc issue create",
@@ -86,6 +87,7 @@ auth_group.short_help = "Authenticate gc with GitCode"  # type: ignore[attr-defi
 issue_group.short_help = "Manage issues"  # type: ignore[attr-defined]
 pr_group.short_help = "Manage pull requests"  # type: ignore[attr-defined]
 compat_group.short_help = "Inspect gc ↔ gh compatibility"  # type: ignore[attr-defined]
+setup_group.short_help = "Configure optional gc integrations"  # type: ignore[attr-defined]
 
 
 @main.command("version", short_help="Show gc version", help="Show gc version.")  # type: ignore[attr-defined]
@@ -107,7 +109,8 @@ main.add_command(auth_group)  # type: ignore[attr-defined]
 main.add_command(issue_group)  # type: ignore[attr-defined]
 main.add_command(pr_group)  # type: ignore[attr-defined]
 main.add_command(compat_group)  # type: ignore[attr-defined]
+main.add_command(setup_group)  # type: ignore[attr-defined]
 
 
 if __name__ == "__main__":  # pragma: no cover
-    main()
+    main()  # type: ignore[call-issue]

gitcode_cli/commands/auth.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import os
+import sys
+
 import click
 
 from ..config import get_token, load_config, save_config
@@ -20,7 +23,7 @@ def auth_group() -> None:
 @click.option("--with-token", is_flag=True, help="Read token from stdin.")
 def auth_login(with_token: bool) -> None:
     if with_token:
-        token = click.get_text_stream("stdin").read().strip()
+        token = sys.stdin.read().strip()
         if not token:
             raise click.ClickException("No token provided on stdin.")
     else:
@@ -53,10 +56,21 @@ def auth_status(json_fields: str | None, jq_query: str | None, template: str | N
     try:
         token = get_token()
     except Exception:
-        safe_echo("Not logged in. Run `gc auth login` to authenticate.")
+        safe_echo("gitcode.com")
+        safe_echo("  X Not logged in to GitCode")
+        safe_echo("  - Run `gc auth login` or set GC_TOKEN to authenticate.")
+        if os.environ.get("GC_GH_PROXY_ACTIVE") == "1":
+            safe_echo("  - gh proxy: active; commands target GitCode, not GitHub")
+            raise click.exceptions.Exit(1) from None
         return
     masked = token[:4] + "****" if len(token) > 4 else "****"
-    safe_echo(f"Logged in to GitCode (token: {masked})")
+    safe_echo("gitcode.com")
+    safe_echo("  ✓ Logged in to GitCode")
+    safe_echo("  - Active account: true")
+    safe_echo("  - API host: https://api.gitcode.com")
+    safe_echo(f"  - Token: {masked}")
+    if os.environ.get("GC_GH_PROXY_ACTIVE") == "1":
+        safe_echo("  - gh proxy: active; commands target GitCode, not GitHub")
 
 
 @auth_group.command("token", short_help="Print the active token", help="Print the active token.")