codna 0.2.12__tar.gz → 0.2.14__tar.gz

{codna-0.2.12 → codna-0.2.14}/PKG-INFO

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

{codna-0.2.12 → codna-0.2.14}/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.12"
+__version__ = "0.2.14"

{codna-0.2.12 → codna-0.2.14}/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/actions-runner-mac-2/_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/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 retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.2.12 → codna-0.2.14}/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.12 → codna-0.2.14}/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.14/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.12 → codna-0.2.14}/codna/webhook.py

@@ -141,6 +141,73 @@ def _safe_ref(value: Any) -> str | None:
     return value if isinstance(value, str) and value and not value.startswith("-") else None
 
 
+# --- feedback-repo cross-repo dispatch (thyn-ai/feedback -> a product's own repo) -----------------
+# Env, not a constant: any company adopting this must be able to point it at their own public
+# intake repo and their own product repos without a code change.
+_FEEDBACK_REPO_ENV = "CODNA_FEEDBACK_REPO"
+_FEEDBACK_ROUTES_ENV = "CODNA_FEEDBACK_ROUTES"
+_PRODUCT_LABEL_RE = re.compile(r"^product:(\S+)$")
+
+
+def feedback_repo() -> str | None:
+    """The public intake repo (e.g. ``thyn-ai/feedback``), or None when unconfigured -- in which
+    case feedback-repo events are just ordinary unrecognized events (204), not an error."""
+    return os.environ.get(_FEEDBACK_REPO_ENV) or None
+
+
+def feedback_routes() -> dict[str, str]:
+    """``{"algenta": "thyn-ai/algenta", ...}`` from CODNA_FEEDBACK_ROUTES (a JSON object). Malformed
+    or absent config yields an empty map -- every report then reports itself unrouted rather than
+    raising, since a config typo must never take down the whole webhook."""
+    raw = os.environ.get(_FEEDBACK_ROUTES_ENV)
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return {str(k): str(v) for k, v in data.items() if isinstance(v, str) and "/" in v}
+
+
+def _product_from_labels(labels: Any) -> str | None:
+    """The bare product name from a ``product:<name>`` label on the issue, if present. The first
+    match wins (an issue should carry exactly one such label)."""
+    if not isinstance(labels, list):
+        return None
+    for entry in labels:
+        name = entry.get("name") if isinstance(entry, dict) else None
+        m = _PRODUCT_LABEL_RE.match(name or "")
+        if m:
+            return m.group(1)
+    return None
+
+
+def _classify_feedback_repo_fix(payload: Mapping[str, Any], *, installation: int | None,
+                                fallback_repo: str) -> WebhookJob:
+    """A ``codna-fix`` label on the public feedback repo: route by the issue's own
+    ``product:<name>`` label to that product's real repo, or explain why it couldn't."""
+    issue = payload.get("issue") or {}
+    number = issue.get("number")
+    product = _product_from_labels(issue.get("labels"))
+    target = feedback_routes().get(product) if product else None
+    ctx: dict[str, Any] = {"feedback_repo": fallback_repo, "feedback_issue": number,
+                           "fp": f"feedback#{number}"}
+    if target:
+        ctx["product"] = product
+        return WebhookJob("fix", target, installation_id=installation, context=ctx,
+                          reason="feedback_routed_fix")
+    reason = (f"no route is configured for product `{product}`" if product
+             else "no `product:<name>` label was found on this report")
+    ctx["routing_error"] = reason
+    # repo_full_name = the FEEDBACK repo itself (there is no target) + issue_number set, so the
+    # existing generic issue-outcome reporting in process_job posts the explanation without any
+    # feedback-specific plumbing -- this case needs none.
+    return WebhookJob("fix", fallback_repo, installation_id=installation, issue_number=number,
+                      context=ctx, reason="feedback_unrouted")
+
+
 def classify_event(event: str, payload: Mapping[str, Any]) -> WebhookJob | None:
     """Map a GitHub ``(event, payload)`` to a Codna job, or ``None`` to ignore it.
 
@@ -206,6 +273,12 @@ def classify_event(event: str, payload: Mapping[str, Any]) -> WebhookJob | None:
     if event == "issues" and action == "labeled":
         label = (payload.get("label") or {}).get("name")
         number = (payload.get("issue") or {}).get("number")
+        fbrepo = feedback_repo()
+        if fbrepo and repo == fbrepo and label == FIX_LABEL and isinstance(number, int):
+            # A report on the public intake repo, approved by a maintainer's codna-fix label:
+            # route it by product to that product's own (often private) repo. Same installation
+            # covers both -- the App is org-wide -- so no separate auth is needed to reach either.
+            return _classify_feedback_repo_fix(payload, installation=installation, fallback_repo=fbrepo)
         if label == FIX_LABEL:
             return WebhookJob("fix", repo, installation_id=installation, issue_number=number, reason="labeled_codna_fix")
         if label == SECURE_LABEL:
@@ -342,7 +415,13 @@ def codna_command(
         return args
     if job.kind == "fix":
         ctx = job.context or {}
-        if ctx:
+        # `in_reply_to_id` is set ONLY by _fix_context_from_review_comment, which itself returns
+        # None when it's absent -- so it is a precise, structural discriminator for "this is a
+        # comment-fix", never a coincidental one. A feedback-routed job has context (product,
+        # feedback_repo, ...) but never this key, so it correctly falls through below instead of
+        # being force-fit into the comment-fix shape (which needs head_ref -- a PR branch that
+        # doesn't exist for an issue filed on a different repo entirely).
+        if ctx.get("in_reply_to_id"):
             # Comment-triggered verified fix of a specific review finding. Analyze the PR head (--ref)
             # and target the PR's OWN branch (--base-branch head_ref) so the fix stacks onto the PR.
             if not ctx.get("head_ref"):
@@ -359,10 +438,18 @@ def codna_command(
             # A fix job with a ref but no comment context and no issue text -- let codna discover
             # what's actually failing by running the repo's own tests against this commit.
             args += ["--ref", job.ref, "--tests"]
-        elif job.issue_number:
-            # Label-triggered (labeled_codna_fix): no commit/tests to run -- `codna fix` requires
-            # one of --issue/--tests/--from-junit or it dies immediately (fix_run.py), so the
-            # caller (run_codna_job) must have already fetched the issue body.
+        elif job.issue_number or issue_text or ctx.get("feedback_issue"):
+            # Label-triggered (labeled_codna_fix, or a feedback-routed report -- both have no
+            # commit/tests to run): `codna fix` requires one of --issue/--tests/--from-junit or it
+            # dies immediately (fix_run.py), so the caller (run_codna_job) must have already
+            # fetched the text -- from the issue itself, or (feedback-routed) from the public
+            # report, since job.issue_number is None there and there is nothing else to fetch.
+            #
+            # `ctx.get("feedback_issue")` alone (without job.issue_number or a passed issue_text)
+            # must STILL enter this branch: a feedback job with NO issue_text supplied is exactly
+            # the fetch-failure case, and skipping this branch entirely would silently build an
+            # incomplete `codna fix --open-pr` with no --issue/--tests, which `codna fix` itself
+            # would then reject at run time instead of failing here with a catchable error.
             if not issue_text:
                 raise WebhookError(
                     "fix_requires_issue_text",
@@ -386,6 +473,13 @@ def codna_command(
                 f"Automated fix opened by the Codna GitHub App for #{job.issue_number}.\n\n"
                 f"{webhook_marker(job)}"
             )
+        elif ctx.get("feedback_repo") and ctx.get("feedback_issue"):
+            # Cross-link to the PUBLIC report, not to job.issue_number (there is none -- the issue
+            # lives on the feedback repo, not this one).
+            body = (
+                f"Automated fix opened by the Codna GitHub App for a report filed at "
+                f"{ctx['feedback_repo']}#{ctx['feedback_issue']}.\n\n{webhook_marker(job)}"
+            )
         args += ["--pr-body", body]
         return args
     raise WebhookError("unknown_job_kind", f"unknown job kind {job.kind!r}")

{codna-0.2.12 → codna-0.2.14}/codna/webhook_worker.py

@@ -156,13 +156,30 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
                   provider: str | None = None, provider_key: str | None = None,
                   codna_bin: str = "codna") -> JobResult:
     """Default runner: run packaged codna for the job in an isolated, scrubbed workspace."""
+    ctx = job.context or {}
+    if job.kind == "fix" and ctx.get("routing_error"):
+        # A report on the feedback repo with no product route: this is a correctly-handled
+        # non-run, not a failure to retry (same convention as the "org not linked" / "automation
+        # disabled" branches in process_job) -- report=True carries the explanation through to the
+        # comment posted on the public issue, and spends nothing running codna for nowhere to go.
+        return JobResult(True, ctx["routing_error"])
     with tempfile.TemporaryDirectory(prefix="codna-webhook-job-") as tmp:
         if job.kind == "secure":
             if not token:
                 return JobResult(False, "secure job needs an installation token to fetch SARIF")
             sarif_path = webhook_github.fetch_code_scanning_sarif(job.repo_full_name, token, dest_dir=tmp)
             argv = codna_command(job, sarif_path=sarif_path)
-        elif job.kind == "fix" and job.issue_number and not (job.context or {}):
+        elif job.kind == "fix" and ctx.get("feedback_issue") and not ctx.get("in_reply_to_id"):
+            # Feedback-routed fix: the issue lives on the FEEDBACK repo, not job.repo_full_name (the
+            # routed TARGET repo this token is scoped to) -- so there is nothing this function can
+            # fetch itself. process_job mints a second, feedback-repo-scoped token and fetches the
+            # text into ctx["issue_text"] before calling this runner; a missing value here means
+            # that fetch failed, and must be reported, not silently swapped for the wrong text.
+            issue_text = ctx.get("issue_text")
+            if not issue_text:
+                return JobResult(False, "feedback-routed fix is missing its report text (fetch failed)")
+            argv = codna_command(job, issue_text=issue_text)
+        elif job.kind == "fix" and job.issue_number and not ctx:
             # Label-triggered fix (no ref, no comment context): `codna fix` needs the issue's own
             # text to know what to fix -- fetch it now, the one thing codna_command can't do itself
             # (it has no token). A fetch failure/empty issue must not silently no-op: report it the
@@ -292,6 +309,27 @@ def process_job(
             github.post_review_comment_reply(job.repo_full_name, token, job.pr_number, reply_to, skip)
             return JobResult(True, f"comment-fix not run: {skip[:120]}")
 
+    # Feedback-routed fix: job.repo_full_name is the ROUTED TARGET repo (that's what the token
+    # minted above is scoped to), but the report text lives on the FEEDBACK repo -- a different
+    # repo under the same installation. Mint a second, feedback-scoped token to read it. A mint or
+    # fetch failure here must not crash the job: run_codna_job's own guard (ctx["issue_text"]
+    # missing) turns it into a clean, reportable JobResult instead.
+    feedback_repo_name = ctx.get("feedback_repo")
+    feedback_issue = ctx.get("feedback_issue")
+    feedback_token: str | None = None
+    if (job.kind == "fix" and feedback_repo_name and feedback_issue and not ctx.get("routing_error")
+            and app_id and private_key and job.installation_id):
+        try:
+            feedback_token = github.installation_token(
+                app_id, private_key, job.installation_id, repo_full_name=feedback_repo_name, kind="fix",
+            )
+        except Exception:  # noqa: BLE001 — a mint failure degrades to a reported fetch failure, not a crash
+            feedback_token = None
+        if feedback_token:
+            issue_text = github.fetch_issue_text(feedback_repo_name, feedback_token, feedback_issue)
+            if issue_text:
+                ctx["issue_text"] = issue_text
+
     # Idempotency: reuse a PR a prior attempt already opened. Checked BEFORE the ack so a redelivery
     # doesn't post a spurious "analyzing…" then "already opened". For a comment-fix only an OPEN PR
     # counts as a live duplicate — a closed prior fix PR must not block re-requesting a fresh one.
@@ -340,13 +378,22 @@ def process_job(
     # opened a correct fix PR and the issue's newest comment was still an OLD failure, so the issue
     # looked broken while the work was done. Now the issue always gets the outcome, with a link.
     if not check_id and not reply_to and token and job.issue_number:
+        if ctx.get("routing_error"):
+            # An unrouted report on the feedback repo itself: job.repo_full_name IS the feedback
+            # repo here (there was no target to route to), so this posts correctly with the SAME
+            # token already minted above -- no feedback-specific plumbing needed for this branch.
+            github.post_issue_comment(
+                job.repo_full_name, token, job.issue_number,
+                f"⚠️ Codna couldn't route this report automatically: {ctx['routing_error']}. "
+                "Add the right `product:<name>` label and re-apply `codna-fix` to retry.",
+            )
         # `job.kind == "fix"` is required for the SUCCESS half: the `codna-secure` label produces an
         # issue-triggered job with no ref and no thread too, but it is a READ-ONLY classification pass
         # that never opens a PR (codna_command builds `codna secure` without --open-pr). Without this
         # term, a clean secure run posted "✅ ... opened a pull request for it." and sent the user
         # hunting for a PR that does not exist -- the same kind of false statement this whole change
         # exists to remove.
-        if result.ok and job.kind == "fix":
+        elif result.ok and job.kind == "fix":
             pr_url = None
             try:
                 pr_url = github.find_open_pr_by_marker(job.repo_full_name, token, webhook_marker(job))
@@ -368,6 +415,26 @@ def process_job(
                 job.repo_full_name, token, job.issue_number,
                 f"⚠️ Codna couldn't finish this fix: {result.summary}",
             )
+    # Feedback-routed fix that DID have a target: job.issue_number is None (there is no issue in the
+    # TARGET repo), so the generic per-issue block above never fires for it -- report back to the
+    # PUBLIC issue instead, using the feedback-scoped token (the job's own `token` is scoped only to
+    # the target repo and cannot post there).
+    if feedback_repo_name and feedback_issue and not ctx.get("routing_error"):
+        comment_token = feedback_token or token
+        if comment_token:
+            if result.ok:
+                pr_url = None
+                try:
+                    # The PR, if any, is in the TARGET repo -- look it up with the token scoped
+                    # there, never with the feedback-scoped token (which cannot see it).
+                    pr_url = github.find_open_pr_by_marker(job.repo_full_name, token, webhook_marker(job))
+                except Exception:  # noqa: BLE001 — never turn a successful fix into a failure over a lookup
+                    pr_url = None
+                msg = (f"✅ Codna opened a fix in {job.repo_full_name}: {pr_url}" if pr_url
+                       else f"✅ Codna finished this fix in {job.repo_full_name} and opened a pull request for it.")
+            else:
+                msg = f"⚠️ Codna couldn't finish this fix in {job.repo_full_name}: {result.summary}"
+            github.post_issue_comment(feedback_repo_name, comment_token, feedback_issue, msg)
     # Reply the outcome ONCE: on success immediately, on failure only when the job is out of retries
     # (else a transient-then-succeeding fix would leave a spurious fail-closed reply, and every failed
     # attempt would spam the thread).

{codna-0.2.12 → codna-0.2.14}/codna.egg-info/PKG-INFO

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

{codna-0.2.12 → codna-0.2.14}/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
@@ -179,10 +182,12 @@ tests/test_telys_runtime_packaging.py
 tests/test_testrun.py
 tests/test_verify_pypi_trusted_publisher.py
 tests/test_webhook.py
+tests/test_webhook_feedback_dispatch.py
 tests/test_webhook_github.py
 tests/test_webhook_metering.py
 tests/test_webhook_queue.py
 tests/test_webhook_worker.py
+tests/test_webhook_worker_feedback_dispatch.py
 tests/test_wheel_guard.py
 tests/test_wheel_smoke_script.py
 tests/test_worker.py

{codna-0.2.12 → codna-0.2.14}/pyproject.toml

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