maintainability-agent 2.4.1__tar.gz → 2.5.0__tar.gz

{maintainability_agent-2.4.1/src/maintainability_agent.egg-info → maintainability_agent-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.4.1
+Version: 2.5.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.4.1**.
+Version **2.5.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
 *and* fixed-form), and the JS/TS family — each by a scanner written for it, and

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0}/README.md

@@ -5,7 +5,7 @@
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.4.1**.
+Version **2.5.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
 *and* fixed-form), and the JS/TS family — each by a scanner written for it, and

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maintainability-agent"
-version = "2.4.1"
+version = "2.5.0"
 description = "Maintainability gate and AI remediation prompt generator for CI."
 readme = "README.md"
 # 3.11, not 3.10. `_discovery`, `_pillars` and `_runner` all import

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.4.1
+Version: 2.5.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.4.1**.
+Version **2.5.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
 *and* fixed-form), and the JS/TS family — each by a scanner written for it, and

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ src/maintainability_audit/_setup_persist.py
 src/maintainability_audit/_skill_install.py
 src/maintainability_audit/_stored_grants.py
 src/maintainability_audit/_tdd_view.py
+src/maintainability_audit/_test_commands.py
 src/maintainability_audit/_test_execution.py
 src/maintainability_audit/_test_pairing.py
 src/maintainability_audit/_tokens.py
@@ -293,6 +294,7 @@ tests/test_stage8_contract.py
 tests/test_suite_isolation.py
 tests/test_swift_declarations.py
 tests/test_tdd_structure.py
+tests/test_test_commands.py
 tests/test_test_execution_class.py
 tests/test_three_presentations.py
 tests/test_trends.py

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "2.4.1"
+__version__ = "2.5.0"

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0}/src/maintainability_audit/_first_run.py

@@ -22,6 +22,7 @@ sat in ``DEFAULTS``, documented as reserved, read by nothing, from
 """
 from __future__ import annotations
 
+import contextlib
 import json
 import sys
 from pathlib import Path
@@ -190,11 +191,53 @@ def maybe_prompt_economics(root: Path, config: dict) -> None:
     print(f"Wrote {written}")
 
 
+def _input_with_default(prompt: str, default: str) -> str:
+    """`input()` with the line pre-filled, where the terminal allows it.
+
+    `readline` is what makes the default *editable* rather than merely
+    described: the text is inserted into the line buffer, so Enter submits
+    it, backspace edits it, and clearing it returns the empty string that
+    has always meant "cancel". Without that, a pre-filled default and a
+    blank-means-cancel rule cannot both be true on one keystroke.
+
+    Absent or unusable `readline` — Windows without pyreadline, a terminal
+    that refuses the hook — falls back to a plain `input()`. The default is
+    still named in the prompt text, so the operator loses the keystroke and
+    not the information. Never let this be the thing that fails a setup.
+    """
+    if not default:
+        return input(prompt)
+    try:
+        import readline
+    except ImportError:
+        return input(prompt)
+
+    def _prefill() -> None:
+        readline.insert_text(default)
+        readline.redisplay()
+
+    try:
+        readline.set_startup_hook(_prefill)
+        return input(prompt)
+    except Exception:  # noqa: BLE001 - a cosmetic hook must not fail setup
+        return input(prompt)
+    finally:
+        # Global state: a hook left installed would pre-type this command
+        # into whatever the session asks next.
+        with contextlib.suppress(Exception):
+            readline.set_startup_hook()
+
+
 def maybe_prompt_test_command(root: Path, config: dict) -> None:
     """Ask the opted-in operator for the test command, once -- the CLI half
     of the Class 5 second stage, mirroring the labor-rate ask. Fires only at
     a TTY, only when the suite was opted into and no command is stored, and
     a blank answer cancels the opt-in. Nothing runs until a command exists.
+
+    Where the tree's manifests name a runner, the line is **pre-filled**
+    with that command rather than merely mentioning it, so this surface and
+    the MCP one carry the same default in the same field: Enter accepts,
+    editing replaces, and clearing the line cancels exactly as before.
     """
     import shlex
 
@@ -209,10 +252,19 @@ def maybe_prompt_test_command(root: Path, config: dict) -> None:
     if (config.get("expected_commands") or {}).get("test"):
         return
 
-    answer = input(
+    from ._test_commands import suggested_test_command
+
+    suggested = suggested_test_command(root)
+    detected = " ".join(suggested.command) if suggested is not None else ""
+    prompt = (
+        f"Detected `{detected}` from {suggested.evidence}. The command that "
+        "runs this repository's test suite (Enter to accept, clear the line "
+        "to cancel running it): "
+        if suggested is not None else
         "The command that runs this repository's test suite, e.g. `pytest` "
         "(Enter to cancel running it): "
-    ).strip()
+    )
+    answer = _input_with_default(prompt, detected).strip()
 
     from ._safe_write import write_bounded
 

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0}/src/maintainability_audit/_mcp_setup.py

@@ -226,21 +226,35 @@ def run_tests_pending(root: Path) -> bool:
             and "test_execution" not in stored)
 
 
-def test_command_questions() -> list[dict[str, Any]]:
+def test_command_questions(root: Path | None = None) -> list[dict[str, Any]]:
     """The one command, asked only of someone who opted into running it.
 
     A free-text answer (empty options), the second stage of the opt-in the
     way the labor rates are the second stage of the economic scenario.
+
+    When the tree's manifests name a runner, that command is the question's
+    `default` and the prompt says which file proposed it. It is a default,
+    not a decision: the operator's answer is what gets stored, and blank
+    still cancels the opt-in — a pre-filled field the operator clears is
+    the same cancellation it always was.
     """
+    from ._test_commands import suggested_test_command
+
+    suggested = suggested_test_command(root) if root is not None else None
+    detected = " ".join(suggested.command) if suggested is not None else ""
+    because = (
+        f"Detected `{detected}` from {suggested.evidence}. "
+        if suggested is not None else ""
+    )
     return [{
         "name": "test_command",
         "prompt": (
-            "The command that runs this repository's test suite "
+            f"{because}The command that runs this repository's test suite "
             "(e.g. `pytest`, `npm test`). It runs in the repository root, "
             "and leaving it blank cancels the opt-in."
         ),
         "options": [],
-        "default": "",
+        "default": detected,
     }]
 
 
@@ -334,7 +348,7 @@ def setup_schema(root: Path | None = None):
     if root is not None and economics_bounds_pending(root):
         return _schema_for(economics_bound_questions())
     if root is not None and test_command_pending(root):
-        return _schema_for(test_command_questions())
+        return _schema_for(test_command_questions(root))
     return _schema_for(setup_questions(load_config(None)))
 
 

maintainability_agent-2.5.0/src/maintainability_audit/_test_commands.py

@@ -0,0 +1,251 @@
+"""The command that runs a repository's tests, read from its build files.
+
+`expected_commands.test` has always been hand-typed. The prompt's example
+was `pytest`, so on every non-Python tree the operator was asked a question
+the repository could already answer: a `Package.swift` beside a `Tests/`
+directory says `swift test` as plainly as a manifest says anything.
+
+**This suggests; it never decides.** The `require_test_command` hard gate
+reads "a *documented* test command", and a command this module wrote into
+the config unasked would satisfy that gate while nobody had documented
+anything — a gate passing on evidence it invented. So detection reaches
+exactly one place: the default offered in the setup question, on every
+surface. A human still answers it, and their answer is what gets stored.
+
+**Every rule is anchored to a manifest**, never to a directory name alone
+or a file extension. `go.mod` means the tree is a Go module; a stray
+`.go` file means someone vendored something. The manifest is recorded as
+`evidence` and travels with the suggestion, so the question can say *why*
+it is proposing this and the operator can disagree with a reason.
+
+**What it refuses to guess**, because a command that cannot run is worse
+than no suggestion:
+
+- **An Xcode project with no `Package.swift`.** `xcodebuild test` needs
+  `-scheme`, and usually `-destination` as well; neither is derivable from
+  the tree with any confidence. The roadmap named `xcodebuild test` as a
+  target and it is deliberately not shipped: bare `xcodebuild test` fails
+  on every project it would be offered for, and a suggestion that always
+  fails teaches the operator to ignore suggestions.
+- **`npm test` where `scripts.test` is the placeholder** npm generates
+  (`echo "Error: no test specified" && exit 1`). It is a script that
+  exists in order not to be a test command.
+- **A package with no tests.** `swift test` on a package with no test
+  target is an error, so `Tests/` or a `.testTarget` in the manifest is
+  required, not just `Package.swift`.
+
+Nothing here runs anything. Detection is file reading, and whether the
+suite may be *executed* remains the Class 5 opt-in, default off.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+#: Bounded like `_practice._read`: a manifest is small, and a multi-megabyte
+#: `package.json` is not a reason to read a multi-megabyte file.
+_READ_LIMIT = 200_000
+
+#: The npm placeholder, written by `npm init` so that `scripts.test` exists.
+#: Matching it loosely on purpose — the wording has changed across npm
+#: versions and the shape has not.
+_NPM_PLACEHOLDER = re.compile(r"no test specified", re.IGNORECASE)
+
+_CMAKE_TESTS = re.compile(r"^\s*(?:enable_testing\s*\(|add_test\s*\()", re.MULTILINE)
+_SWIFT_TEST_TARGET = re.compile(r"\.testTarget\s*\(")
+_PYTEST_DECLARED = re.compile(
+    r"^\s*\[(?:tool\.pytest[.\]]|pytest\]|tool:pytest\])", re.MULTILINE
+)
+
+
+@dataclass(frozen=True)
+class TestCommand:
+    """A suggested command and the file that suggested it."""
+
+    command: list[str]
+    evidence: str
+
+
+def _read(path: Path) -> str:
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as handle:
+            return handle.read(_READ_LIMIT)
+    except OSError:
+        return ""
+
+
+def _swift(root: Path) -> TestCommand | None:
+    """SwiftPM, and only where a test target exists to run.
+
+    `swift test` on a package without one exits non-zero, so `Package.swift`
+    alone is not enough. Either spelling of "there are tests here" counts:
+    the conventional `Tests/` directory, or a `.testTarget` the manifest
+    declares somewhere else.
+    """
+    manifest = root / "Package.swift"
+    if not manifest.is_file():
+        return None
+    has_tests = (root / "Tests").is_dir() or bool(
+        _SWIFT_TEST_TARGET.search(_read(manifest))
+    )
+    return TestCommand(["swift", "test"], "Package.swift") if has_tests else None
+
+
+def _fortran(root: Path) -> TestCommand | None:
+    """`fpm.toml` is the Fortran Package Manager's manifest.
+
+    `_practice` already reads this file for fortitude's lint settings, so
+    the tree shape is one this tool understood before it could name the
+    command that tests it.
+    """
+    return (
+        TestCommand(["fpm", "test"], "fpm.toml")
+        if (root / "fpm.toml").is_file()
+        else None
+    )
+
+
+def _rust(root: Path) -> TestCommand | None:
+    return (
+        TestCommand(["cargo", "test"], "Cargo.toml")
+        if (root / "Cargo.toml").is_file()
+        else None
+    )
+
+
+def _go(root: Path) -> TestCommand | None:
+    """`./...` because a bare `go test` tests only the root package.
+
+    The difference matters in a module with any structure at all: the bare
+    form silently tests almost nothing and exits zero, which is the worst
+    available outcome for a command whose job is to fail.
+    """
+    return (
+        TestCommand(["go", "test", "./..."], "go.mod")
+        if (root / "go.mod").is_file()
+        else None
+    )
+
+
+def _cmake(root: Path) -> TestCommand | None:
+    """`ctest`, but only where the project actually registered tests.
+
+    A `CMakeLists.txt` without `enable_testing()` or `add_test()` builds
+    something that has no tests to run, and `ctest` there reports "No tests
+    were found" and exits non-zero.
+    """
+    manifest = root / "CMakeLists.txt"
+    if not manifest.is_file() or not _CMAKE_TESTS.search(_read(manifest)):
+        return None
+    return TestCommand(["ctest"], "CMakeLists.txt")
+
+
+def _node(root: Path) -> TestCommand | None:
+    """`npm test`, unless the script is npm's own placeholder."""
+    manifest = root / "package.json"
+    if not manifest.is_file():
+        return None
+    try:
+        parsed = json.loads(_read(manifest))
+    except (json.JSONDecodeError, ValueError):
+        return None
+    if not isinstance(parsed, dict):
+        return None
+    script = (parsed.get("scripts") or {}).get("test")
+    if not isinstance(script, str) or not script.strip():
+        return None
+    if _NPM_PLACEHOLDER.search(script):
+        return None
+    return TestCommand(["npm", "test"], "package.json")
+
+
+def _python(root: Path) -> TestCommand | None:
+    """pytest where a file declares it, not where a `tests/` folder exists.
+
+    A directory named `tests` says nothing about the runner. A
+    `[tool.pytest.ini_options]`, `[pytest]` or `[tool:pytest]` section is a
+    repository stating which runner it uses, which is the only thing worth
+    reading it for.
+    """
+    if (root / "pytest.ini").is_file():
+        return TestCommand(["pytest"], "pytest.ini")
+    for name in ("pyproject.toml", "tox.ini", "setup.cfg"):
+        manifest = root / name
+        if manifest.is_file() and _PYTEST_DECLARED.search(_read(manifest)):
+            return TestCommand(["pytest"], name)
+    return None
+
+
+def _maven(root: Path) -> TestCommand | None:
+    return (
+        TestCommand(["mvn", "test"], "pom.xml")
+        if (root / "pom.xml").is_file()
+        else None
+    )
+
+
+def _gradle(root: Path) -> TestCommand | None:
+    """The wrapper when the repository ships one, because that is the point.
+
+    A checked-in `gradlew` pins the Gradle version the build expects;
+    calling bare `gradle` uses whatever the machine happens to have, which
+    is the thing the wrapper exists to prevent.
+    """
+    for name in ("build.gradle", "build.gradle.kts"):
+        if (root / name).is_file():
+            wrapper = (root / "gradlew").is_file()
+            return TestCommand(["./gradlew" if wrapper else "gradle", "test"], name)
+    return None
+
+
+def _dotnet(root: Path) -> TestCommand | None:
+    for pattern in ("*.sln", "*.slnx"):
+        found = sorted(root.glob(pattern))
+        if found:
+            return TestCommand(["dotnet", "test"], found[0].name)
+    projects = sorted(root.glob("*.csproj"))
+    return TestCommand(["dotnet", "test"], projects[0].name) if projects else None
+
+
+#: Order is the tie-break and is therefore part of the contract: a tree with
+#: both a `Package.swift` and a `package.json` gets one answer, the same one
+#: every time (P1). Ecosystems whose manifest is unambiguous come first;
+#: `package.json` is late because it is the file most often present in a
+#: repository whose real subject is something else.
+_DETECTORS = (
+    _swift,
+    _fortran,
+    _rust,
+    _go,
+    _cmake,
+    _maven,
+    _gradle,
+    _dotnet,
+    _python,
+    _node,
+)
+
+
+def detect_test_commands(root: Path) -> list[TestCommand]:
+    """Every command this tree's manifests support, in a fixed order.
+
+    Plural because a repository may honestly have more than one — a Swift
+    package with a Node-based docs site is not a malformed tree — and
+    reporting only the first would hide that from anyone deciding.
+    """
+    root = Path(root)
+    found = [detector(root) for detector in _DETECTORS]
+    return [item for item in found if item is not None]
+
+
+def suggested_test_command(root: Path) -> TestCommand | None:
+    """The one command to offer as the setup question's default, or `None`.
+
+    `None` is a real answer and the common one: most trees this tool audits
+    will not carry a manifest it recognises, and the question is then asked
+    exactly as it always was.
+    """
+    found = detect_test_commands(root)
+    return found[0] if found else None

{maintainability_agent-2.4.1 → maintainability_agent-2.5.0}/src/maintainability_audit/config.py

@@ -11,7 +11,7 @@ from ._config_defaults import DEFAULT_CONFIG, DEFAULT_IDIOM_GROUPS
 # still the door every caller comes through.
 __all__ = ["DEFAULT_CONFIG", "DEFAULT_IDIOM_GROUPS", "PROJECT_URL", "VERSION"]
 
-VERSION = "2.4.1"
+VERSION = "2.5.0"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"