codna 0.2.87__tar.gz → 0.2.89__tar.gz

{codna-0.2.87 → codna-0.2.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.87
+Version: 0.2.89
 Summary: Understand. Fix. Evolve. Codna maps your repository before it spends a token, reviews pull requests, fixes bugs and proves which scanner findings are reachable. Runs on your machine.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.87 → codna-0.2.89}/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.87"
+__version__ = "0.2.89"

{codna-0.2.87 → codna-0.2.89}/codna/mcp_server.py

@@ -10,12 +10,24 @@ from __future__ import annotations
 
 import asyncio
 import hashlib
+import importlib.util
 import json
 import os
 from pathlib import Path
+from typing import Annotated
 
 from .cli import _api_key, _client, _dump, _register, _runtime_keys
 
+# FastMCP builds each tool's input schema by evaluating the Annotated[str, Field(...)]
+# annotations below against THIS module's globals (inspect.signature(eval_str=True)), so
+# pydantic's Field must resolve here whenever a server can be built. But this module must also
+# import without pydantic: the offline CI lane installs neither pydantic nor the mcp extra and
+# exercises the *_json handlers directly. Keying the import to pydantic's presence satisfies
+# both — a server can only be built when the mcp extra (which hard-requires pydantic) exists,
+# so the binding is never absent when FastMCP evaluates the annotations.
+if importlib.util.find_spec("pydantic") is not None:
+    from pydantic import Field
+
 LOGIN_REQUIRED_MESSAGE = (
     "requires the one-time free `codna login` device authorization (free community license); "
     "run `codna login` once — fully offline thereafter"
@@ -245,6 +257,10 @@ def _build_server():
     def codna_triage(repo: str = ".", issue: str = "") -> str:
         """Understand a repository and locate the code relevant to an issue.
 
+        The sibling tools act, this one maps: codna_fix plans/acts on one bug and
+        codna_recall retrieves stored code memory — triage is the zero-token map +
+        suspect-file list you run first.
+
         Requires the one-time free `codna login` device authorization (free community
         license); fully offline thereafter.
 
@@ -280,21 +296,44 @@ def _build_server():
         openWorldHint=True,
     ))
     async def codna_fix(
-        repo: str = ".", issue: str = "", ref: str = "", open_pr: bool = False,
-        model: str = "repository.verified_agentic_v1",
+        repo: Annotated[str, Field(
+            description="A local path or a git URL. open_pr=true requires a git URL (a local "
+                        "checkout has no remote to push to). Default '.': the current "
+                        "directory, or the server default set by `codna mcp start --repo` "
+                        "(env CODNA_MCP_DEFAULT_REPO).",
+        )] = ".",
+        issue: Annotated[str, Field(
+            description="What's broken — e.g. the failing test or the observed behavior. "
+                        "Required when open_pr=true; otherwise optional but strongly "
+                        "recommended (an empty issue yields a generic repo-wide plan).",
+        )] = "",
+        ref: Annotated[str, Field(
+            description="Branch, tag, or commit to analyze: the planner's repository "
+                        "snapshot is taken at this ref (registration forwards it to "
+                        "create_repository_snapshot). Default '': the repo's current state — "
+                        "the checkout as-is for a local path, the default branch for a git URL.",
+        )] = "",
+        open_pr: Annotated[bool, Field(
+            description="false (default): READ-ONLY plan — returns root cause, confidence and "
+                        "a patch reference, and changes nothing. true: pushes a fix branch "
+                        "and OPENS A PULL REQUEST — needs a git URL for repo and GITHUB_TOKEN "
+                        "(or CODNA_GITHUB_TOKEN) with write access; returns pull_request_url.",
+        )] = False,
+        model: Annotated[str, Field(
+            description="Provider-qualified planner model, e.g. openai/gpt-5. Default "
+                        "'repository.verified_agentic_v1' (codna's verified agentic runtime).",
+        )] = "repository.verified_agentic_v1",
     ) -> str:
         """Find and fix a bug. Runs the full Codna agent + engine + risk simulation.
 
         Requires the one-time free `codna login` device authorization (free community
         license) plus a provider key (BYOK — e.g. ANTHROPIC_API_KEY or `codna key set
-        anthropic`); fully offline thereafter.
+        anthropic`). Offline truth: planning calls the provider API (network), and only
+        open_pr=true writes to GitHub — codna_triage, codna_secure and codna_recall are
+        the fully-offline tools.
 
-        repo: a local path or a git URL. issue: what's broken (e.g. the failing test).
-        model: optional provider-qualified model such as openai/gpt-5.
-        open_pr: when false (default) this is READ-ONLY — returns the plan (root cause, confidence,
-          patch reference) and changes nothing. When true, codna pushes a fix branch and OPENS A
-          PULL REQUEST — this needs a git URL for `repo` and a GITHUB_TOKEN with write access.
         Returns the root cause, confidence, model, and (when open_pr) the pull_request_url.
+        Failures come back as 'codna_fix error: ...' text — the tool never raises.
         """
         return await asyncio.to_thread(fix_json, repo, issue, ref, open_pr, model)
 
@@ -306,16 +345,41 @@ def _build_server():
         # Reads one local SARIF file; never starts the sidecar or touches the network.
         openWorldHint=False,
     ))
-    def codna_secure(repo: str = ".", sarif_path: str = "", ref: str = "") -> str:
-        """Prove which scanner findings are reachable. Ingests a SARIF report (CodeQL /
+    def codna_secure(
+        sarif_path: Annotated[str, Field(
+            description="Path to the scanner's SARIF 2.1.0 report (CodeQL, Semgrep, Snyk, "
+                        "Trivy, or any other scanner). REQUIRED — there is no auto-discovery: "
+                        "omitting it fails input validation, and an empty string returns "
+                        "'codna_secure error: sarif_path is required'.",
+        )],
+        repo: Annotated[str, Field(
+            description="Repository the findings belong to (a local path or a git URL), echoed "
+                        "as 'repository' in the output for traceability. The classification "
+                        "reads ONLY the SARIF file — repo is never scanned. Default '.': the "
+                        "current directory, or the server default set by `codna mcp start "
+                        "--repo` (env CODNA_MCP_DEFAULT_REPO).",
+        )] = ".",
+        ref: Annotated[str, Field(
+            description="Branch, tag, or commit the SARIF was produced from. Accepted for "
+                        "parity with `codna secure --ref`; informational only in the MCP path — "
+                        "the local SARIF-only classifier does not resolve it. Default ''.",
+        )] = "",
+    ) -> str:
+        """Prove which scanner findings are reachable. Ingests a SARIF 2.1.0 report (CodeQL /
         Semgrep / Snyk / Trivy), classifies each finding (exploitable / production-reachable /
-        unreachable / unknown) via the engine, and reports which are autofix-eligible.
-        Read-only and 0 LLM tokens. `sarif_path` is required.
+        unreachable / unknown) via the local engine, and reports which are autofix-eligible.
+        Read-only, deterministic, 0 LLM tokens — the SARIF file is the only input read; the
+        repo is never scanned and the agent sidecar never starts.
+
+        `sarif_path` is REQUIRED (see the input schema) — there is no workspace scan or
+        default-path fallback. SARIF provenance (tool name + revision) must be complete or the
+        report is rejected. All failures come back as 'codna_secure error: ...' text — the
+        tool never raises.
 
         Requires the one-time free `codna login` device authorization (free community
         license); fully offline thereafter.
         """
-        return secure_json(repo, sarif_path, ref)
+        return secure_json(repo=repo, sarif_path=sarif_path, ref=ref)
 
     @server.tool(annotations=ToolAnnotations(
         title="Recall code from local memory",
@@ -368,6 +432,7 @@ def _build_server():
     ) -> 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.
+        It only files the issue — codna_fix is the one that can open a PR with the fix.
 
         Requires the one-time free `codna login` device authorization (free community
         license); auto-filing additionally needs a GitHub token (else a pre-filled URL).

{codna-0.2.87 → codna-0.2.89}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.87
+Version: 0.2.89
 Summary: Understand. Fix. Evolve. Codna maps your repository before it spends a token, reviews pull requests, fixes bugs and proves which scanner findings are reachable. Runs on your machine.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.87 → codna-0.2.89}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.87"
+version = "0.2.89"
 description = "Understand. Fix. Evolve. Codna maps your repository before it spends a token, reviews pull requests, fixes bugs and proves which scanner findings are reachable. Runs on your machine."
 readme = "README.md"
 requires-python = ">=3.12"

{codna-0.2.87 → codna-0.2.89}/tests/test_mcp_enrich.py

@@ -49,6 +49,75 @@ def test_full_hint_annotations():
     assert tools["codna_report_bug"].annotations.openWorldHint is True
 
 
+def test_codna_secure_schema_marks_sarif_path_required_and_documents_params():
+    """TDQS: prose said sarif_path is required while the schema had it optional, and ref/repo
+    carried no semantics. The handler (secure_json) errors on omission — there is no
+    auto-discovery — so the served schema must say required and document every parameter."""
+    s = _build_server()
+    tools = {t.name: t for t in asyncio.run(s.list_tools())}
+    schema = tools["codna_secure"].inputSchema
+
+    assert schema["required"] == ["sarif_path"]
+    props = schema["properties"]
+    assert set(props) == {"sarif_path", "repo", "ref"}
+    assert "default" not in props["sarif_path"]  # required: no default to lean on
+    assert props["repo"]["default"] == "."
+    assert props["ref"]["default"] == ""
+    for name in ("sarif_path", "repo", "ref"):
+        assert props[name].get("description"), f"{name} must carry parameter semantics"
+    # The honest-truth claims behind each description (guarded against future drift):
+    assert "no auto-discovery" in props["sarif_path"]["description"]
+    assert "never scanned" in props["repo"]["description"]  # classification reads ONLY the SARIF
+    assert "does not resolve it" in props["ref"]["description"]  # `del ref` in secure_json
+
+
+def test_codna_fix_schema_documents_all_params_and_the_precise_offline_truth():
+    """TDQS: codna_fix's ref was unexplained and "fully offline thereafter" was ambiguous.
+    ref is NOT ignored here (unlike codna_secure): fix_json forwards it to _plan_once /
+    run_fix, and registration puts it into create_repository_snapshot (cli.py:372-375) —
+    the planner's snapshot is taken at that ref. The schema must say so."""
+    s = _build_server()
+    tools = {t.name: t for t in asyncio.run(s.list_tools())}
+    schema = tools["codna_fix"].inputSchema
+
+    assert "required" not in schema  # every fix parameter is optional
+    props = schema["properties"]
+    assert set(props) == {"repo", "issue", "ref", "open_pr", "model"}
+    assert props["repo"]["default"] == "."
+    assert props["issue"]["default"] == ""
+    assert props["ref"]["default"] == ""
+    assert props["open_pr"]["default"] is False
+    assert props["model"]["default"] == "repository.verified_agentic_v1"
+    for name in ("repo", "issue", "ref", "open_pr", "model"):
+        assert props[name].get("description"), f"{name} must carry parameter semantics"
+    # ref is USED, not ignored: snapshot-at-ref semantics must be the documented one.
+    assert "snapshot is taken at this ref" in props["ref"]["description"]
+    assert "create_repository_snapshot" in props["ref"]["description"]
+
+    # The precise offline sentence, not the ambiguous "fully offline thereafter":
+    desc = tools["codna_fix"].description
+    assert "codna login" in desc  # login disclosure (see test_mcp_login_gate.py)
+    assert "fully offline thereafter" not in desc
+    assert "planning calls the provider API (network)" in desc
+    assert "only" in desc and "open_pr=true writes to GitHub" in desc
+    assert "codna_triage, codna_secure and codna_recall are" in desc  # the fully-offline set
+
+
+def test_sibling_contrast_lines():
+    """TDQS: triage names what the siblings do instead; report_bug contrasts with codna_fix."""
+    s = _build_server()
+    tools = {t.name: t for t in asyncio.run(s.list_tools())}
+
+    triage = tools["codna_triage"].description
+    assert "codna_fix plans/acts on one bug" in triage
+    assert "codna_recall retrieves stored code memory" in triage
+    assert "run first" in triage
+
+    report = tools["codna_report_bug"].description
+    assert "only files the issue" in report
+    assert "codna_fix is the one that can open a PR with the fix" in report
+
+
 def test_resource_and_prompt_registered():
     s = _build_server()
     assert "codna://capabilities" in [str(r.uri) for r in asyncio.run(s.list_resources())]