codna 0.2.11__tar.gz → 0.2.13__tar.gz

{codna-0.2.11 → codna-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.11
+Version: 0.2.13
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.11 → codna-0.2.13}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.2.11"
+__version__ = "0.2.13"

{codna-0.2.11 → codna-0.2.13}/codna/agent-core/run-server.bundle.mjs

@@ -110643,7 +110643,7 @@ var init_bowser = __esm(() => {
 
 // agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/Users/angel/Developer/actions-runner/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/Users/angel/actions-runner-mac-4/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.2.11 → codna-0.2.13}/codna/ci_admission.py

@@ -27,7 +27,7 @@ slot, so the wait is bounded (`CODNA_CI_MAX_WAIT_S`) and expiry admits rather th
 """
 from __future__ import annotations
 
-import fcntl
+import contextlib
 import json
 import os
 import platform
@@ -60,6 +60,9 @@ DEFAULT_MAX_WAIT_S = 120.0        # bounded: a waiting job is still holding a ru
 DEFAULT_POLL_S = 5.0
 DEFAULT_LEASE_MAX_AGE_S = 6 * 3600.0
 DURATION_WINDOW = 200
+_LOCK_WAIT_S = 10.0               # then run unlocked -- a lock file must never block a build
+_LOCK_STALE_S = 60.0              # older than this, its holder died mid-section
+_LOCK_POLL_S = 0.05
 
 
 def _env_float(name: str, default: float) -> float:
@@ -241,24 +244,50 @@ class LeaseStore:
         self.durations_dir.mkdir(parents=True, exist_ok=True)
 
     # ── locking ────────────────────────────────────────────────────────────────────────────────
+    @contextlib.contextmanager
     def _locked(self):
-        """flock around check-and-reserve, so two runners cannot both see the last free slot."""
+        """Exclusive lock around check-and-reserve, so two runners cannot both take the last slot.
+
+        Uses an O_EXCL lock FILE rather than `fcntl.flock`. flock is the obvious choice and is
+        POSIX-only: importing it made this whole module fail to import on Windows, so a Windows
+        runner could not run the gate at all. `os.open(..., O_CREAT | O_EXCL)` is atomic on every
+        platform Python supports, and nothing here may assume an OS — the fleet is meant to be
+        adoptable on any runner.
+
+        Two safety valves, because a lock must never be able to wedge CI:
+          * a lock older than `_LOCK_STALE_S` is stolen — its holder died mid-section;
+          * if it still cannot be taken within `_LOCK_WAIT_S`, the section runs UNLOCKED. Briefly
+            risking an over-admit is strictly better than blocking a build on a lock file.
+        """
         self.ensure_dirs()
-        fh = open(self.lock_path, "a+")
-
-        class _Guard:
-            def __enter__(self_inner):
-                fcntl.flock(fh, fcntl.LOCK_EX)
-                return fh
-
-            def __exit__(self_inner, *exc):
+        deadline = time.monotonic() + _LOCK_WAIT_S
+        fd = None
+        while fd is None:
+            try:
+                fd = os.open(str(self.lock_path), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+            except FileExistsError:
                 try:
-                    fcntl.flock(fh, fcntl.LOCK_UN)
+                    if time.time() - os.path.getmtime(self.lock_path) > _LOCK_STALE_S:
+                        os.unlink(self.lock_path)
+                        continue
+                except OSError:
+                    pass            # vanished under us — just retry
+                if time.monotonic() >= deadline:
+                    break           # proceed unlocked rather than block CI
+                time.sleep(_LOCK_POLL_S)
+            except OSError:
+                break               # unwritable state dir — proceed unlocked
+        try:
+            yield fd
+        finally:
+            if fd is not None:
+                try:
+                    os.close(fd)
                 finally:
-                    fh.close()
-                return False
-
-        return _Guard()
+                    try:
+                        os.unlink(self.lock_path)
+                    except OSError:
+                        pass
 
     # ── occupancy ──────────────────────────────────────────────────────────────────────────────
     @staticmethod

{codna-0.2.11 → codna-0.2.13}/codna/cli.py

@@ -24,6 +24,7 @@ from .focus_paths import _issue_focus_paths  # focus-path extraction (split out
 from .agent_core_runtime import ensure_agent_core_running, inspect_agent_core_runtime, stop_agent_core_runtime
 from .local_mojo_pool import legacy_global_mojo_worker_diagnostics, mojo_worker_diagnostics
 from .ci_cli import register as _register_ci
+from .report_cli import register as _register_report
 from .mcp_cli import cmd_mcp as _cmd_mcp
 from .webhook_cli import cmd_webhook as _cmd_webhook
 from .remote_http import RemoteHttpTimeoutError, remote_http_timeout
@@ -928,6 +929,7 @@ def build_parser() -> argparse.ArgumentParser:
     pstat.set_defaults(func=cmd_status)
 
     _register_ci(sub)
+    _register_report(sub)
 
     pl = sub.add_parser("login", help="Sign this machine into a Codna account (device-code login).")
     pl.add_argument("--token", help="headless access token (or env CODNA_TOKEN) — skips the browser step")

{codna-0.2.11 → codna-0.2.13}/codna/mcp_server.py

@@ -63,6 +63,28 @@ def recall_json(repo: str = ".", query: str = "", service: str = "", language: s
         return f"codna_recall error: {exc}"
 
 
+def report_bug_json(
+    title: str, body: str = "", product: str = "codna", include_diagnostics: bool = False,
+) -> str:
+    """File a report to thyn-ai/feedback and return the result as JSON, without crashing the MCP
+    server. Same submission path `codna report` (the CLI) uses, so an agent and a human land in
+    the same place with the same fields."""
+    if not title:
+        return "codna_report_bug error: title is required"
+    try:
+        from .report_cli import submit_report
+
+        result = submit_report(title=title, product=product, body=body,
+                               attach_diagnostics=include_diagnostics)
+        return json.dumps({
+            "submitted": result.submitted,
+            "url": result.url,
+            "local_path": result.local_path,
+        }, indent=2)
+    except Exception as exc:  # noqa: BLE001 - surface as tool text, never crash the MCP server.
+        return f"codna_report_bug error: {exc}"
+
+
 def secure_json(repo: str = ".", sarif_path: str = "", ref: str = "") -> str:
     """Return local SARIF reachability classification as JSON for MCP.
 
@@ -235,6 +257,23 @@ def _build_server():
         """Recall relevant code from the local Telys memory, if installed."""
         return recall_json(repo, query, service, language, final_k)
 
+    @server.tool(annotations=ToolAnnotations(title="Report a bug, feature, or question", readOnlyHint=False))
+    async def codna_report_bug(
+        title: str, body: str = "", product: str = "codna", include_diagnostics: bool = False,
+    ) -> str:
+        """File a report to thyn-ai/feedback — the public front door for algenta, codna, telys,
+        and sqai. Files the same shape of issue `codna report` (the CLI) does.
+
+        title: a short summary, e.g. "codna fix hangs on a monorepo".
+        body: what happened, or what you want — as much detail as you have.
+        product: one of algenta, codna, telys, sqai, accounts, docs (default: codna).
+        include_diagnostics: attach the same redacted output `codna doctor` prints — no secret
+          values, only which config sources are set. Off by default.
+        Returns the filed issue's URL, or — if it couldn't file automatically (no GitHub token
+        reachable, offline) — a pre-filled URL for a human to finish submitting.
+        """
+        return await asyncio.to_thread(report_bug_json, title, body, product, include_diagnostics)
+
     @server.resource("codna://capabilities")
     def capabilities() -> str:
         """codna's MCP capabilities — @-mentionable so the client knows what codna offers."""
@@ -245,6 +284,7 @@ def _build_server():
                 "codna_fix": "find + fix a bug (root cause, patch ref, confidence, optional model)",
                 "codna_secure": "prove which scanner findings are reachable (read-only)",
                 "codna_recall": "recall code from local on-device memory",
+                "codna_report_bug": "file a bug/feature/question to thyn-ai/feedback",
             },
             "default_repo": os.environ.get("CODNA_MCP_DEFAULT_REPO", "."),
         }, indent=2)

codna-0.2.13/codna/report_cli.py

@@ -0,0 +1,218 @@
+"""`codna report` — file a report to thyn-ai's public feedback repo (thyn-ai/feedback).
+
+One of three doors into the same intake: humans use the issue forms in a browser, scripts use
+`gh issue create` against the same forms, and this is the door for a terminal or an AI agent
+driving the CLI directly. The MCP tool `codna_report_bug` (mcp_server.py) wraps this module's
+`submit_report()`, so all three paths produce an identically-shaped issue.
+
+Never fails the caller's session, by design: any submission error — no token, no network, an
+air-gapped machine — falls back to writing the report to a local file and printing a pre-filled
+`github.com/.../issues/new` URL instead of raising. Filing a report is the point; losing what the
+user already typed because GitHub was unreachable would defeat it.
+
+Diagnostics are attached only when the caller opts in (`--attach-diagnostics`), and only the
+redacted payload `codna doctor` itself would print — see `doctor.build_report` /
+`doctor.format_public_output`. Nothing here reads or sends anything the user didn't ask for; see
+CLAUDE.md's no-phone-home policy — this command is the explicitly-user-initiated exception it
+carves out, not a channel that runs on its own.
+"""
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+import subprocess
+import time
+import urllib.parse
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+
+from . import __version__
+
+FEEDBACK_REPO = os.environ.get("CODNA_FEEDBACK_REPO", "thyn-ai/feedback")
+PRODUCTS = ("algenta", "codna", "telys", "sqai", "accounts", "docs")
+_REQUEST_TIMEOUT_S = 15.0
+
+
+def _local_fallback_dir() -> Path:
+    """Honors CODNA_RUNTIME_ROOT like every other piece of codna's local state (the webhook
+    queue, the local-stack state file) — a hardcoded ~/.codna here would be the one path in the
+    runtime that can't be sandboxed or redirected the way everything else can."""
+    root = os.environ.get("CODNA_RUNTIME_ROOT")
+    base = Path(root).expanduser() if root else Path.home() / ".codna"
+    return base / "reports"
+
+
+@dataclass(frozen=True)
+class ReportResult:
+    ok: bool
+    submitted: bool  # True: a real issue was filed. False: prefill URL / local file fallback.
+    url: str
+    local_path: str | None = None
+
+
+def _github_token() -> str | None:
+    """A token to file the issue AS THE USER — never the App's installation credentials, which
+    have nothing to do with this command. `GITHUB_TOKEN`/`GH_TOKEN` first (CI/script-friendly),
+    then `gh auth token` if the `gh` CLI is on PATH and already logged in (the common dev-machine
+    case, so most developers need to type nothing extra)."""
+    for var in ("GITHUB_TOKEN", "GH_TOKEN"):
+        value = os.environ.get(var)
+        if value:
+            return value
+    if not shutil.which("gh"):
+        return None
+    try:
+        result = subprocess.run(
+            ["gh", "auth", "token"], capture_output=True, text=True, check=False, timeout=10,
+        )
+    except OSError:
+        return None
+    token = result.stdout.strip()
+    return token if result.returncode == 0 and token else None
+
+
+def _redacted_diagnostics() -> str:
+    """Exactly what `codna doctor --json` prints — never a raw env dump, never a secret value."""
+    try:
+        from .doctor import build_report, format_public_output
+
+        return format_public_output(build_report(), json_output=True)
+    except Exception as exc:  # noqa: BLE001 - diagnostics are a nice-to-have, never fatal to the report
+        return json.dumps({"diagnostics_unavailable": str(exc)})
+
+
+def normalize_product(product: str | None) -> str:
+    value = (product or "").strip().lower()
+    return value if value in PRODUCTS else "not sure"
+
+
+def build_report_body(*, body: str, product: str, attach_diagnostics: bool) -> str:
+    """The rendered body, shaped to match bug_report.yml's fields so a human reading it in
+    thyn-ai/feedback sees the same structure whichever door the report came through."""
+    parts = [
+        f"### Which product?\n\n{normalize_product(product)}",
+        f"### Version\n\ncodna {__version__}",
+        f"### Platform\n\n{platform.platform()} / Python {platform.python_version()}",
+        f"### What happened?\n\n{body.strip() or '(no description given)'}",
+    ]
+    if attach_diagnostics:
+        parts.append(
+            "### Diagnostics (redacted — presence/source only, never a secret value)\n\n"
+            f"```json\n{_redacted_diagnostics()}\n```"
+        )
+    return "\n\n".join(parts)
+
+
+def prefill_url(*, title: str, body: str) -> str:
+    """Zero-auth fallback: GitHub issue forms accept field values via query params, so this works
+    even for someone with no GITHUB_TOKEN and no `gh` login — they just have to click Submit."""
+    query = urllib.parse.urlencode({"template": "bug_report.yml", "title": title, "what-happened": body})
+    return f"https://github.com/{FEEDBACK_REPO}/issues/new?{query}"
+
+
+def _write_local_fallback(*, title: str, body: str) -> Path:
+    directory = _local_fallback_dir()
+    directory.mkdir(parents=True, exist_ok=True)
+    path = directory / f"{int(time.time())}.md"
+    path.write_text(f"# {title}\n\n{body}\n", encoding="utf-8")
+    return path
+
+
+def submit_report(*, title: str, product: str, body: str, attach_diagnostics: bool) -> ReportResult:
+    """Try to file a real issue; on ANY failure (no token, no network, GitHub unreachable), write
+    the report locally and return a pre-filled URL instead. Always returns; never raises — the
+    worst case for the caller is "paste this URL yourself", never "the report is gone"."""
+    full_body = build_report_body(body=body, product=product, attach_diagnostics=attach_diagnostics)
+    fallback_url = prefill_url(title=title, body=full_body)
+    token = _github_token()
+
+    if token:
+        try:
+            response = httpx.post(
+                f"https://api.github.com/repos/{FEEDBACK_REPO}/issues",
+                json={"title": title, "body": full_body},
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Accept": "application/vnd.github+json",
+                    "User-Agent": f"codna-cli/{__version__}",
+                },
+                timeout=_REQUEST_TIMEOUT_S,
+            )
+            if response.status_code == 201:
+                return ReportResult(ok=True, submitted=True, url=response.json()["html_url"])
+        except httpx.HTTPError:
+            pass  # network/DNS/TLS failure (e.g. air-gapped) -- fall through to the local bundle
+
+    local_path = None
+    try:
+        local_path = str(_write_local_fallback(title=title, body=full_body))
+    except OSError:
+        pass  # even the local write failing must not stop the URL from being printed
+    return ReportResult(ok=True, submitted=False, url=fallback_url, local_path=local_path)
+
+
+# ── the `codna report` command ───────────────────────────────────────────────────────────────────
+def _prompt_for_body() -> str:
+    print("Describe what happened (empty line to finish):")
+    lines: list[str] = []
+    while True:
+        try:
+            line = input("> ")
+        except (EOFError, KeyboardInterrupt):
+            break
+        if not line:
+            break
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def cmd_report(args) -> int:
+    import sys
+
+    product = normalize_product(getattr(args, "product", None))
+    body = getattr(args, "body", None) or ""
+    attach = bool(getattr(args, "attach_diagnostics", False))
+    # Only prompt when nothing was given AND there is an actual human at the other end of stdin —
+    # a script or an agent piping this command must never block waiting for input that never comes.
+    if not body and sys.stdin.isatty():
+        body = _prompt_for_body()
+
+    if getattr(args, "dry_run", False):
+        print(f"product: {product}")
+        print(f"title  : {args.title}")
+        print("body:")
+        print(build_report_body(body=body, product=product, attach_diagnostics=attach))
+        return 0
+
+    result = submit_report(title=args.title, product=product, body=body, attach_diagnostics=attach)
+    if result.submitted:
+        print(f"filed: {result.url}")
+        return 0
+
+    print("could not file this automatically — open the link below to finish submitting it:")
+    print(f"  {result.url}")
+    if result.local_path:
+        print(f"(also saved a copy at {result.local_path} in case the link expires or you're offline)")
+    return 0
+
+
+def register(sub) -> None:
+    """Attach `codna report` to the top-level subparsers. Lives here, not in cli.py, for the same
+    reason `byok_cli`/`ci_cli` do — cli.py is held under a hard line ceiling by `test_modularity`."""
+    pr = sub.add_parser(
+        "report",
+        help="File a bug/feature/question to thyn-ai/feedback — the public front door for every product.",
+    )
+    pr.add_argument("title", help="short title, e.g. \"codna fix hangs on a monorepo\"")
+    pr.add_argument("--product", choices=PRODUCTS, default="codna",
+                    help="which product this is about (default: codna)")
+    pr.add_argument("--body", default="", help="the description; omit to be prompted interactively")
+    pr.add_argument("--attach-diagnostics", action="store_true",
+                    help="attach the same redacted output as `codna doctor` (no secret values)")
+    pr.add_argument("--dry-run", action="store_true",
+                    help="print exactly what would be sent; submits nothing")
+    pr.set_defaults(func=cmd_report)

{codna-0.2.11 → codna-0.2.13}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.11
+Version: 0.2.13
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.11 → codna-0.2.13}/codna.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ codna/python_import_paths.py
 codna/refengine.py
 codna/remote_http.py
 codna/repo_backend.py
+codna/report_cli.py
 codna/repository_artifacts.py
 codna/review.py
 codna/review_findings.py
@@ -139,6 +140,7 @@ tests/test_mcp_default_repo.py
 tests/test_mcp_enrich.py
 tests/test_mcp_install.py
 tests/test_mcp_recall.py
+tests/test_mcp_report_bug.py
 tests/test_mcp_secure.py
 tests/test_memory_errors.py
 tests/test_memory_hybrid.py
@@ -159,6 +161,7 @@ tests/test_policy.py
 tests/test_refengine.py
 tests/test_release_readiness.py
 tests/test_repo_backend.py
+tests/test_report_cli.py
 tests/test_repository_artifacts.py
 tests/test_review_findings.py
 tests/test_rules_and_review.py

{codna-0.2.11 → codna-0.2.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.11"
+version = "0.2.13"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

{codna-0.2.11 → codna-0.2.13}/tests/test_ci_admission.py

@@ -374,6 +374,69 @@ def test_job_class_cannot_escape_the_state_directory():
     assert ci._safe_name("") == "job"
 
 
+# ── platform agnostic: the fleet must be adoptable on any runner ───────────────────────────────────
+def test_the_gate_imports_without_posix_only_modules():
+    """REGRESSION. The lock was `fcntl.flock`, and `import fcntl` is POSIX-only — so this module
+    could not even be IMPORTED on Windows and a Windows runner could not run the gate at all. The
+    gate is meant to work on any platform, so it must not depend on an OS-specific module.
+
+    Checked structurally because the suite itself runs on POSIX, where a regression would pass
+    silently: importing fcntl here succeeds, so only the absence of the import proves portability.
+
+    Parsed with `ast` rather than grepped: a substring check matches the module's own docstring
+    (which names `fcntl.flock` to explain why it is gone) and so fails while the code is correct —
+    the same false-positive trap as asserting on a comment.
+    """
+    import ast
+    import inspect
+
+    imported: set[str] = set()
+    for node in ast.walk(ast.parse(inspect.getsource(ci))):
+        if isinstance(node, ast.Import):
+            imported.update(alias.name.split(".")[0] for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            imported.add(node.module.split(".")[0])
+
+    posix_only = imported & {"fcntl", "msvcrt", "termios", "pwd", "grp"}
+    assert not posix_only, f"platform-specific dependency reintroduced: {sorted(posix_only)}"
+
+
+def test_locking_survives_a_holder_that_died_mid_section(tmp_path, monkeypatch):
+    """A crashed job must not wedge the fleet. An O_EXCL lock file has no OS-level owner, so nothing
+    releases it automatically — an abandoned lock is stolen once it is older than the stale window.
+
+    Asserts it happens PROMPTLY, not merely that it happens: the fail-open path would eventually
+    admit anyway after `_LOCK_WAIT_S`, so a lease-only assertion passes with stealing removed
+    entirely (verified by mutation). The elapsed time is what distinguishes stolen from waited-out.
+    """
+    monkeypatch.setattr(ci, "_LOCK_WAIT_S", 5.0)
+    store = ci.LeaseStore(tmp_path / "s")
+    store.ensure_dirs()
+    store.lock_path.write_text("")                      # an abandoned lock, no owner
+    old = ci.time.time() - (ci._LOCK_STALE_S + 60)
+    os.utime(store.lock_path, (old, old))
+
+    started = ci.time.monotonic()
+    lease, _, _ = store.acquire("j", {}, lambda live: (True, "ok"))
+    elapsed = ci.time.monotonic() - started
+
+    assert lease is not None, "a stale lock must be stolen, not waited on forever"
+    assert elapsed < 1.0, f"stale lock was waited out ({elapsed:.1f}s), not stolen"
+
+
+def test_locking_never_blocks_a_build_indefinitely(tmp_path, monkeypatch):
+    """If the lock cannot be taken at all, the section runs UNLOCKED rather than blocking. Briefly
+    risking an over-admit is strictly better than failing a build on a lock file."""
+    monkeypatch.setattr(ci, "_LOCK_WAIT_S", 0.05)
+    monkeypatch.setattr(ci, "_LOCK_STALE_S", 10_000.0)   # fresh enough that it is never stolen
+    store = ci.LeaseStore(tmp_path / "s")
+    store.ensure_dirs()
+    store.lock_path.write_text("")                       # held, and not stale
+
+    lease, _, _ = store.acquire("j", {}, lambda live: (True, "ok"))
+    assert lease is not None, "an unavailable lock must not block admission"
+
+
 # ── fail open, always ──────────────────────────────────────────────────────────────────────────────
 def test_admission_failure_admits_rather_than_blocking_ci(tmp_path, monkeypatch):
     """The gate is infrastructure protecting throughput; it must never become the reason a build

codna-0.2.13/tests/test_mcp_report_bug.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import asyncio
+import json
+
+import pytest
+
+from codna import mcp_server, report_cli
+
+
+def _mcp_available() -> bool:
+    try:
+        import mcp.server.fastmcp  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def test_report_bug_json_files_through_submit_report(monkeypatch):
+    """The MCP tool must call the SAME submission path the CLI uses, not a parallel
+    reimplementation -- that's the whole point of an agent and a human landing in one place."""
+    captured = {}
+
+    def _fake_submit(*, title, product, body, attach_diagnostics):
+        captured.update(title=title, product=product, body=body,
+                        attach_diagnostics=attach_diagnostics)
+        return report_cli.ReportResult(ok=True, submitted=True,
+                                       url="https://github.com/thyn-ai/feedback/issues/9")
+
+    monkeypatch.setattr(report_cli, "submit_report", _fake_submit)
+
+    payload = json.loads(mcp_server.report_bug_json(
+        "a title", body="the body", product="telys", include_diagnostics=True,
+    ))
+
+    assert captured == {"title": "a title", "product": "telys", "body": "the body",
+                        "attach_diagnostics": True}
+    assert payload == {"submitted": True, "url": "https://github.com/thyn-ai/feedback/issues/9",
+                       "local_path": None}
+
+
+def test_report_bug_json_requires_a_title():
+    assert "error" in mcp_server.report_bug_json("")
+
+
+def test_report_bug_json_never_crashes_the_server_on_a_submission_error(monkeypatch):
+    def _boom(**_kw):
+        raise RuntimeError("network is on fire")
+
+    monkeypatch.setattr(report_cli, "submit_report", _boom)
+    result = mcp_server.report_bug_json("a title")
+
+    assert "codna_report_bug error" in result
+    assert "network is on fire" in result
+
+
+def test_report_bug_json_surfaces_the_fallback_local_path(monkeypatch):
+    monkeypatch.setattr(report_cli, "submit_report", lambda **_kw: report_cli.ReportResult(
+        ok=True, submitted=False, url="https://github.com/x/new", local_path="/tmp/x.md"))
+    payload = json.loads(mcp_server.report_bug_json("a title"))
+    assert payload["submitted"] is False
+    assert payload["local_path"] == "/tmp/x.md"
+
+
+# ── mcp-gated: exercised only when the optional `mcp` extra is installed ───────────────────────────
+@pytest.mark.skipif(not _mcp_available(), reason="mcp extra not installed")
+def test_report_bug_tool_is_registered_with_write_intent():
+    """codna_report_bug files a real GitHub issue -- it must be flagged as a write, unlike
+    codna_triage/codna_secure/codna_recall, or an MCP client might treat it as side-effect-free
+    and call it speculatively. Uses FastMCP's own public `list_tools()`, not private internals."""
+    server = mcp_server._build_server()
+    tools = {t.name: t for t in asyncio.run(server.list_tools())}
+    assert "codna_report_bug" in tools
+    assert tools["codna_report_bug"].annotations.readOnlyHint is False
+
+
+@pytest.mark.skipif(not _mcp_available(), reason="mcp extra not installed")
+def test_capabilities_resource_mentions_report_bug():
+    server = mcp_server._build_server()
+    resources = {str(r.uri) for r in asyncio.run(server.list_resources())}
+    assert "codna://capabilities" in resources
+    content = asyncio.run(server.read_resource("codna://capabilities"))
+    text = "".join(c.content for c in content if hasattr(c, "content"))
+    assert "codna_report_bug" in text

{codna-0.2.11 → codna-0.2.13}/tests/test_packaging.py

@@ -426,7 +426,17 @@ def test_cli_publish_workflow_uses_trusted_publishing_and_contract_verification(
     assert "telys runtime install" not in workflow
     assert workflow.count("python scripts/verify_cli_wheel_tags.py --cli-dir cli") == 2
     assert workflow.count("python -m twine check cli/dist/*") == 2
-    assert "pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b" in workflow
+    # Pinned to a full 40-hex commit SHA, never a floating tag: a mutable ref on the action that
+    # uploads releases is a supply-chain hole. Asserted as a PROPERTY, not as one literal SHA --
+    # a hardcoded SHA fails on every LEGITIMATE re-pin (this one broke when the org aligned action
+    # refs org-wide to stop self-hosted runner cache thrash), and the only available fix is "bump
+    # the constant", which is not review and provides no real protection.
+    pypi_pins = re.findall(r"pypa/gh-action-pypi-publish@(\S+)", workflow)
+    assert pypi_pins, "the OIDC publish path must use pypa/gh-action-pypi-publish"
+    for _ref in pypi_pins:
+        assert re.fullmatch(r"[0-9a-f]{40}", _ref), (
+            f"pypa/gh-action-pypi-publish must be pinned to a full commit SHA, got {_ref!r}"
+        )
     # Publish auth policy: trusted-publisher OIDC is PREFERRED; a GATED PyPI API-token fallback is
     # allowed so a release does not hard-block on trusted-publisher registration (which is a one-time
     # PyPI UI step). The token/password credential is confined to the token-gated publish step