codna 0.2.12__tar.gz → 0.2.13__tar.gz

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

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

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

{codna-0.2.12 → 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/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/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.12 → 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.12 → 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.12 → codna-0.2.13}/codna.egg-info/PKG-INFO

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

{codna-0.2.12 → 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.12 → codna-0.2.13}/pyproject.toml

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

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