agentirc-cli 9.13.0__tar.gz → 9.13.1__tar.gz

{agentirc_cli-9.13.0 → agentirc_cli-9.13.1}/.github/workflows/tests.yml

@@ -24,6 +24,11 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: read
+    # A presence flag, not the secret: `secrets.*` isn't allowed in `if:`.
+    # Fork and Dependabot PRs get no SONAR_TOKEN, so the SonarCloud gate skips
+    # there instead of waiting out its 300 s timeout.
+    env:
+      SONAR_TOKEN_PRESENT: ${{ secrets.SONAR_TOKEN != '' }}
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
 
@@ -57,6 +62,19 @@ jobs:
           UV_PROJECT_ENVIRONMENT: .venv
         run: uv run pytest -n auto -v
 
+      # No unresolved SonarCloud issue on the PR. SonarCloud's automatic analysis
+      # (the GitHub App) scans the PR; a code smell leaves its quality gate green,
+      # so this fails the job while the PR has any OPEN or CONFIRMED issue.
+      # ACCEPTED and FALSE_POSITIVE ones pass. Cited from culture-rules (#43).
+      - name: SonarCloud unresolved issues
+        if: steps.bootstrap.outputs.ready == 'true' && env.SONAR_TOKEN_PRESENT == 'true' && github.event_name == 'pull_request'
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+          SONAR_HOST_URL: https://sonarcloud.io
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python3 scripts/sonar-pr-issues.py
+
   version-check:
     needs: lint
     runs-on: ubuntu-latest

{agentirc_cli-9.13.0 → agentirc_cli-9.13.1}/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [9.13.1] - 2026-10-30
+
+### Added
+
+- CI fails a pull request that has an unresolved SonarCloud issue: after
+  SonarCloud's automatic analysis of the PR's head commit,
+  `scripts/sonar-pr-issues.py` (cited from culture-rules) fails on any OPEN or
+  CONFIRMED issue. ACCEPTED and FALSE_POSITIVE issues pass. Same gate as
+  culture, irc-lens and culture-library. `sonar-project.properties` names the
+  project key for it.
+
 ## [9.13.0] - 2026-10-30
 
 First agentirc release that presents itself as CULTURE.DEV on the wire —

{agentirc_cli-9.13.0 → agentirc_cli-9.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentirc-cli
-Version: 9.13.0
+Version: 9.13.1
 Summary: Agent-friendly IRCd: server core for AI agent meshes
 Project-URL: Homepage, https://github.com/agentculture/agentirc
 Project-URL: Issues, https://github.com/agentculture/agentirc/issues

{agentirc_cli-9.13.0 → agentirc_cli-9.13.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentirc-cli"
-version = "9.13.0"
+version = "9.13.1"
 description = "Agent-friendly IRCd: server core for AI agent meshes"
 readme = "README.md"
 license = "Apache-2.0"

agentirc_cli-9.13.1/scripts/sonar-pr-issues.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+# Cited from agentculture/culture-rules@48942c3 scripts/sonar-pr-issues.py (cite, don't import).
+"""Fail a pull request that has unresolved SonarCloud issues.
+
+SonarCloud's quality gate can pass with open issues on new code (a code smell does not
+turn it red), so CI runs this right after the scan: it waits until SonarCloud's analysis
+of the PR is for the PR's head commit, then lists the PR's issues whose status is OPEN or
+CONFIRMED and exits 1 when there is any. ACCEPTED and FALSE_POSITIVE issues are resolved
+by a person and pass; FIXED ones are gone.
+
+Environment: ``SONAR_HOST_URL`` (the server; defaults to localhost so nothing outside is
+called by accident), ``SONAR_PROJECT_KEY`` (else ``sonar.projectKey`` from
+``sonar-project.properties``), ``PR_NUMBER``, ``HEAD_SHA`` and optionally ``SONAR_TOKEN``.
+Exit codes: 0 no unresolved issue, 1 unresolved issues, 2 the analysis or the API could
+not be read. Standard library only.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import sys
+import time
+import urllib.parse
+import urllib.request
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any
+
+UNRESOLVED = ("OPEN", "CONFIRMED")
+PAGE_SIZE = 100
+WAIT_S = 300
+POLL_S = 10
+
+Fetch = Callable[[str, Mapping[str, str]], Mapping[str, Any]]
+
+
+def project_key(env: Mapping[str, str], root: Path) -> str:
+    """``SONAR_PROJECT_KEY``, else ``sonar.projectKey`` from ``sonar-project.properties``."""
+    if env.get("SONAR_PROJECT_KEY"):
+        return env["SONAR_PROJECT_KEY"]
+    for line in (root / "sonar-project.properties").read_text().splitlines():
+        name, _, value = line.partition("=")
+        if name.strip() == "sonar.projectKey" and value.strip():
+            return value.strip()
+    raise SystemExit("sonar-pr-issues: no SONAR_PROJECT_KEY and no sonar.projectKey")
+
+
+def http_fetch(host: str, token: str | None) -> Fetch:
+    """A GET of ``host + path`` with ``params``, as JSON (token as basic auth, if any)."""
+
+    def fetch(path: str, params: Mapping[str, str]) -> Mapping[str, Any]:
+        url = f"{host.rstrip('/')}{path}?{urllib.parse.urlencode(params)}"
+        req = urllib.request.Request(url)  # noqa: S310 - the host is the configured server
+        if token:
+            basic = base64.b64encode(f"{token}:".encode()).decode()
+            req.add_header("Authorization", f"Basic {basic}")
+        with urllib.request.urlopen(req, timeout=30) as resp:  # nosec B310
+            return json.load(resp)
+
+    return fetch
+
+
+def analysed_commit(fetch: Fetch, project: str, pr: str) -> str | None:
+    """The commit SonarCloud last analysed for pull request ``pr``, or ``None``."""
+    data = fetch("/api/project_pull_requests/list", {"project": project})
+    for item in data.get("pullRequests") or ():
+        if str(item.get("key")) == pr:
+            commit = item.get("commit") or {}
+            sha = commit.get("sha")
+            return sha if isinstance(sha, str) else None
+    return None
+
+
+def wait_for_analysis(
+    fetch: Fetch,
+    project: str,
+    pr: str,
+    head: str,
+    *,
+    wait_s: float = WAIT_S,
+    poll_s: float = POLL_S,
+    sleep: Callable[[float], None] = time.sleep,
+    clock: Callable[[], float] = time.monotonic,
+) -> bool:
+    """True once the PR's analysis is for ``head``; False when ``wait_s`` runs out."""
+    deadline = clock() + wait_s
+    while True:
+        if analysed_commit(fetch, project, pr) == head:
+            return True
+        if clock() >= deadline:
+            return False
+        sleep(poll_s)
+
+
+def unresolved_issues(fetch: Fetch, project: str, pr: str) -> list[Mapping[str, Any]]:
+    """Every OPEN or CONFIRMED issue of pull request ``pr``, across pages."""
+    out: list[Mapping[str, Any]] = []
+    page = 1
+    while True:
+        data = fetch(
+            "/api/issues/search",
+            {
+                "componentKeys": project,
+                "pullRequest": pr,
+                "issueStatuses": ",".join(UNRESOLVED),
+                "ps": str(PAGE_SIZE),
+                "p": str(page),
+            },
+        )
+        issues = [i for i in data.get("issues") or () if isinstance(i, Mapping)]
+        out.extend(issues)
+        total = data.get("total")
+        if not issues or not isinstance(total, int) or len(out) >= total:
+            return out
+        page += 1
+
+
+def describe(issue: Mapping[str, Any], project: str) -> str:
+    """One line: rule, file and line, severity, message."""
+    component = str(issue.get("component") or "").removeprefix(f"{project}:")
+    line = issue.get("line")
+    where = f"{component}:{line}" if line else component
+    return (
+        f"[{issue.get('rule')}] {where} ({issue.get('severity')}, "
+        f"{issue.get('issueStatus') or issue.get('status')}): {issue.get('message')}"
+    )
+
+
+def main(
+    env: Mapping[str, str] | None = None,
+    fetch: Fetch | None = None,
+    root: Path | None = None,
+    sleep: Callable[[float], None] = time.sleep,
+) -> int:
+    env = os.environ if env is None else env
+    root = Path(__file__).resolve().parents[1] if root is None else root
+    pr, head = env.get("PR_NUMBER", ""), env.get("HEAD_SHA", "")
+    if not pr or not head:
+        print("sonar-pr-issues: PR_NUMBER and HEAD_SHA are required", file=sys.stderr)
+        return 2
+    project = project_key(env, root)
+    if fetch is None:
+        host = env.get("SONAR_HOST_URL") or "http://localhost:9000"
+        fetch = http_fetch(host, env.get("SONAR_TOKEN") or None)
+    try:
+        if not wait_for_analysis(fetch, project, pr, head, sleep=sleep):
+            print(
+                f"sonar-pr-issues: no SonarCloud analysis of PR #{pr} at {head[:12]}",
+                file=sys.stderr,
+            )
+            return 2
+        issues = unresolved_issues(fetch, project, pr)
+    except (OSError, ValueError) as exc:  # URLError is an OSError; bad JSON a ValueError
+        print(f"sonar-pr-issues: SonarCloud could not be read: {exc}", file=sys.stderr)
+        return 2
+    if not issues:
+        print(f"SonarCloud: PR #{pr} has no unresolved issue (accepted ones pass)")
+        return 0
+    print(f"SonarCloud: PR #{pr} has {len(issues)} unresolved issue(s); fix or accept each:")
+    for issue in issues:
+        print(f"  - {describe(issue, project)}")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agentirc_cli-9.13.1/sonar-project.properties

@@ -0,0 +1,6 @@
+# SonarCloud project identity. agentirc is analysed by SonarCloud's automatic
+# analysis (the GitHub App), not by a CI scan step, so this file is not read by
+# a scanner. scripts/sonar-pr-issues.py reads sonar.projectKey from it to find
+# the PR's analysis and its unresolved issues.
+sonar.projectKey=agentculture_agentirc
+sonar.organization=agentculture

agentirc_cli-9.13.1/tests/test_sonar_pr_issues.py

@@ -0,0 +1,128 @@
+# Cited from agentculture/culture-rules@48942c3 tests/test_sonar_pr_issues.py
+# (cite, don't import); PROJECT is agentirc's key.
+"""Tests for scripts/sonar-pr-issues.py: a PR with an unresolved SonarCloud issue fails CI.
+
+The SonarCloud API is a fake ``fetch`` keyed by path; nothing outside is called.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = REPO_ROOT / "scripts" / "sonar-pr-issues.py"
+
+_spec = importlib.util.spec_from_file_location("sonar_pr_issues", SCRIPT)
+spi = importlib.util.module_from_spec(_spec)
+assert _spec.loader is not None
+sys.modules["sonar_pr_issues"] = spi
+_spec.loader.exec_module(spi)
+
+PROJECT = "agentculture_agentirc"
+HEAD = "c8207ca" + "0" * 33
+ENV = {"PR_NUMBER": "43", "HEAD_SHA": HEAD, "SONAR_PROJECT_KEY": PROJECT}
+
+
+def issue(rule="python:S3776", status="OPEN", line=153):
+    return {
+        "rule": rule,
+        "component": f"{PROJECT}:culture_rules/events/emit.py",
+        "line": line,
+        "severity": "CRITICAL",
+        "issueStatus": status,
+        "message": "Refactor this function",
+    }
+
+
+class FakeSonar:
+    """``/api/project_pull_requests/list`` answers ``commits`` in turn (the last repeats);
+    ``/api/issues/search`` answers the issues whose status was asked for, one per page."""
+
+    def __init__(self, commits, issues=()):
+        self.commits = list(commits)
+        self.issues = list(issues)
+        self.calls = []
+
+    def __call__(self, path, params):
+        self.calls.append((path, dict(params)))
+        if path == "/api/project_pull_requests/list":
+            sha = self.commits.pop(0) if len(self.commits) > 1 else self.commits[0]
+            return {"pullRequests": [{"key": "42"}, {"key": "43", "commit": {"sha": sha}}]}
+        wanted = params["issueStatuses"].split(",")
+        found = [i for i in self.issues if i["issueStatus"] in wanted]
+        page = int(params["p"])
+        return {"total": len(found), "issues": found[page - 1 : page]}
+
+
+def run(fake, capsys):
+    code = spi.main(env=ENV, fetch=fake, root=REPO_ROOT, sleep=lambda s: None)
+    return code, capsys.readouterr()
+
+
+def test_a_pr_without_issues_passes(capsys):
+    code, out = run(FakeSonar([HEAD]), capsys)
+    assert code == 0
+    assert "no unresolved issue" in out.out
+
+
+def test_an_open_issue_fails_and_is_listed(capsys):
+    code, out = run(FakeSonar([HEAD], [issue()]), capsys)
+    assert code == 1
+    assert "[python:S3776] culture_rules/events/emit.py:153" in out.out
+
+
+def test_accepted_and_false_positive_issues_pass(capsys):
+    fake = FakeSonar([HEAD], [issue(status="ACCEPTED"), issue(status="FALSE_POSITIVE")])
+    code, _ = run(fake, capsys)
+    assert code == 0
+    (search,) = [p for path, p in fake.calls if path == "/api/issues/search"]
+    assert search["issueStatuses"] == "OPEN,CONFIRMED"
+
+
+def test_a_confirmed_issue_fails(capsys):
+    code, _ = run(FakeSonar([HEAD], [issue(status="CONFIRMED")]), capsys)
+    assert code == 1
+
+
+def test_every_page_is_read(capsys):
+    issues = [issue(line=n) for n in range(1, 4)]
+    code, out = run(FakeSonar([HEAD], issues), capsys)
+    assert code == 1
+    assert "3 unresolved issue(s)" in out.out
+
+
+def test_it_waits_for_the_analysis_of_the_head_commit(capsys):
+    fake = FakeSonar(["old" + "0" * 37, "old" + "0" * 37, HEAD], [issue()])
+    code, _ = run(fake, capsys)
+    assert code == 1
+    lists = [c for c in fake.calls if c[0] == "/api/project_pull_requests/list"]
+    assert len(lists) == 3
+
+
+def test_no_analysis_of_the_head_is_an_environment_error(capsys):
+    ticks = iter(range(0, 10_000, 100))
+    fake = FakeSonar(["old" + "0" * 37])
+    ok = spi.wait_for_analysis(
+        fake, PROJECT, "43", HEAD, wait_s=300, sleep=lambda s: None, clock=lambda: next(ticks)
+    )
+    assert ok is False
+
+
+def test_an_unreadable_api_is_an_environment_error(capsys):
+    def broken(path, params):
+        raise OSError("connection refused")
+
+    code, out = run(broken, capsys)
+    assert code == 2
+    assert "could not be read" in out.err
+
+
+def test_the_project_key_comes_from_sonar_project_properties():
+    assert spi.project_key({}, REPO_ROOT) == PROJECT
+
+
+def test_missing_pr_or_head_is_an_environment_error(capsys):
+    code = spi.main(env={}, fetch=FakeSonar([HEAD]), root=REPO_ROOT, sleep=lambda s: None)
+    assert code == 2

{agentirc_cli-9.13.0 → agentirc_cli-9.13.1}/uv.lock

@@ -10,7 +10,7 @@ resolution-markers = [
 
 [[package]]
 name = "agentirc-cli"
-version = "9.13.0"
+version = "9.13.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },