maintainability-agent 3.6.2__tar.gz → 3.6.3__tar.gz

{maintainability_agent-3.6.2/src/maintainability_agent.egg-info → maintainability_agent-3.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.6.2
+Version: 3.6.3
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -46,7 +46,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 **3.6.2**.
+Version **3.6.3**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Go, Rust, PHP, Ruby, Swift,
 COBOL, Fortran (free-form *and* fixed-form), and the JS/TS/HTML family — each

{maintainability_agent-3.6.2 → maintainability_agent-3.6.3}/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 **3.6.2**.
+Version **3.6.3**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Go, Rust, PHP, Ruby, Swift,
 COBOL, Fortran (free-form *and* fixed-form), and the JS/TS/HTML family — each

{maintainability_agent-3.6.2 → maintainability_agent-3.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maintainability-agent"
-version = "3.6.2"
+version = "3.6.3"
 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-3.6.2 → maintainability_agent-3.6.3/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.6.2
+Version: 3.6.3
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -46,7 +46,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 **3.6.2**.
+Version **3.6.3**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Go, Rust, PHP, Ruby, Swift,
 COBOL, Fortran (free-form *and* fixed-form), and the JS/TS/HTML family — each

{maintainability_agent-3.6.2 → maintainability_agent-3.6.3}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -182,6 +182,7 @@ tests/test_band_concealment_p3.py
 tests/test_band_pressures.py
 tests/test_bands.py
 tests/test_body_or_signature_class.py
+tests/test_build_output_is_not_the_repositorys_code.py
 tests/test_c_declarations.py
 tests/test_calibration_corpus.py
 tests/test_calibration_drift.py

{maintainability_agent-3.6.2 → maintainability_agent-3.6.3}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "3.6.2"
+__version__ = "3.6.3"

{maintainability_agent-3.6.2 → maintainability_agent-3.6.3}/src/maintainability_audit/_discovery.py

@@ -222,8 +222,31 @@ def _text_of(path: Path) -> str:
     return "\n".join(read_source_file(path))
 
 
+#: The evidence recorded for a path the repository ignores and git does not
+#: track (D175), so a reader can see why it left the scored population.
+IGNORED_BUILD_OUTPUT_EVIDENCE = (
+    "untracked, and excluded by this repository's .gitignore "
+    "(git ls-files --others --ignored)"
+)
+
+
+def _ignored_build_output(root: Path) -> dict[str, str]:
+    """Untracked paths the repository's `.gitignore` excludes (D175).
+
+    A Maven build copied jsoup's test resources into `target/test-classes`,
+    and the next audit scored 29 more files — one a failing file — as the
+    team's own. The same commit scored one way before a build and another
+    after it. `target/` is not added to a list of names: ADR 010 §1 forbids
+    that, and the next build tool will choose another word. The repository
+    already says which paths are not its source.
+    """
+    from .git_tools import ignored_untracked_paths
+
+    return dict.fromkeys(ignored_untracked_paths(root), IGNORED_BUILD_OUTPUT_EVIDENCE)
+
+
 def _generated_directories(root: Path, excludes: tuple[str, ...]) -> dict[str, str]:
-    """Directories a `package.json` script deletes and rebuilds."""
+    """Directories a `package.json` script deletes and rebuilds, then ignored build output."""
     found: dict[str, str] = {}
     for manifest in root.rglob("package.json"):
         relative = manifest.relative_to(root).as_posix()
@@ -237,6 +260,10 @@ def _generated_directories(root: Path, excludes: tuple[str, ...]) -> dict[str, s
                     f"deleted and rebuilt by `{name}` in {relative}: "
                     f"`{str(command)[:60]}`",
                 )
+    # A manifest's own statement about a directory is the more specific
+    # evidence, so it wins where both apply.
+    for path, evidence in _ignored_build_output(root).items():
+        found.setdefault(path, evidence)
     return found
 
 
@@ -458,10 +485,18 @@ def discover(root: Path, config: dict[str, Any]) -> Inventory:
     inventory.directories = _directory_provenance(
         vendored_dirs, generated_dirs, asset_dirs)
     seen_directories: set[tuple[str, str]] = set()
+    # What the scanner reads, beyond source code: a generated or vendored
+    # tree's HTML, XML and JSON are scored too unless classified here (D175).
+    read = set((config.get("paths") or {}).get("include_extensions", ()))
+    not_ours_dirs = (*generated_dirs, *vendored_dirs)
     for path in sorted(root.rglob("*")):
-        if not path.is_file() or path.suffix not in KNOWN_SOURCE_SUFFIXES:
+        if not path.is_file():
             continue
         relative = path.relative_to(root).as_posix()
+        if path.suffix not in KNOWN_SOURCE_SUFFIXES and not (
+            path.suffix in read and any(_under(relative, owner) for owner in not_ours_dirs)
+        ):
+            continue
         if is_excluded(relative, list(excludes)):
             continue
         verdict, evidence, owner = _classify(

{maintainability_agent-3.6.2 → maintainability_agent-3.6.3}/src/maintainability_audit/config.py

@@ -20,7 +20,7 @@ from ._operator_reads import (
 # still the door every caller comes through.
 __all__ = ["DEFAULT_CONFIG", "DEFAULT_IDIOM_GROUPS", "PROJECT_URL", "VERSION"]
 
-VERSION = "3.6.2"
+VERSION = "3.6.3"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"
 

{maintainability_agent-3.6.2 → maintainability_agent-3.6.3}/src/maintainability_audit/git_tools.py

@@ -231,6 +231,36 @@ def probe_git(args: list[str], cwd: Path) -> str:
         return ""
 
 
+def ignored_untracked_paths(root: Path) -> set[str]:
+    """Paths the repository's own `.gitignore` files exclude and git does not track (D175).
+
+    A build writes `target/`, `out/` or `bin/` into the working tree, and the
+    repository's `.gitignore` is where it says those are not its source.
+    That is evidence the repository provides, so ADR 010 can act on it where
+    a list of directory names cannot.
+
+    Only the per-directory `.gitignore` files are read. `--exclude-standard`
+    would also honour `.git/info/exclude` and the user's `core.excludesFile`,
+    which differ by machine — the same commit would then score differently
+    on two laptops (P1). A tracked file matched by an ignore rule is not
+    listed, because git tracks it, and an untracked file that is *not*
+    ignored stays in: that is uncommitted work, which D56 keeps visible.
+
+    Directories come back with a trailing slash, which is stripped. A tree
+    git cannot read — not a repository, git absent — yields nothing, which
+    is the absence of evidence rather than a verdict.
+    """
+    try:
+        output = run_git(
+            ["ls-files", "--others", "--ignored",
+             "--exclude-per-directory=.gitignore", "--directory", "-z"],
+            root, strip=False,
+        )
+    except GitCommandFailed:
+        return set()
+    return {entry.rstrip("/") for entry in output.split("\0") if entry.strip("/")}
+
+
 def changed_paths(root: Path, revspec: str) -> set[str]:
     """Paths touched by `revspec`, as forward-slash relative strings.
 

maintainability_agent-3.6.3/tests/test_build_output_is_not_the_repositorys_code.py

@@ -0,0 +1,165 @@
+"""A build does not change what an audit scores (D175).
+
+A Maven build copied jsoup's test resources into `target/test-classes`, and
+the next audit scored 29 more files — one of them a failing file — as the
+team's own. The same commit scored one way before `mvn test` and another
+after it, which is P1 failing on the working tree rather than on the code.
+
+ADR 010 §1 forbids the obvious fix: `target/` on a list of names is the
+`ggml/` mistake again, waiting for the next build tool to pick another word.
+The repository already says which paths are not its source: its own
+`.gitignore`, for paths git does not track.
+
+The claim: **every file the scanner reads, placed in an untracked path the
+repository ignores, leaves the scored population and is counted** — and
+nothing else does. The population is every suffix in the shipped
+`include_extensions`, so HTML, XML and JSON are covered along with source.
+"""
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def _git(repo: Path, *args: str) -> None:
+    subprocess.run(["git", "-C", str(repo), *args], check=True, capture_output=True)
+
+
+def _config() -> dict[str, Any]:
+    from maintainability_audit.config import load_config
+
+    return load_config(None)
+
+
+def _failing_file(path: Path, config: dict[str, Any]) -> None:
+    """A file the scanner reads and grades as failing, whatever its suffix."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = int(config["thresholds"]["max_file_lines"]) + 5
+    path.write_text("".join(f"line {number}\n" for number in range(lines)), encoding="utf-8")
+
+
+def _repo(tmp_path: Path) -> Path:
+    repo = tmp_path / "repo"
+    (repo / "src").mkdir(parents=True)
+    (repo / "src" / "app.py").write_text("def run():\n    return 1\n", encoding="utf-8")
+    (repo / ".gitignore").write_text("out/\n", encoding="utf-8")
+    _git(repo, "init", "-q")
+    _git(repo, "add", ".")
+    return repo
+
+
+def _scored(report: dict[str, Any]) -> dict[str, Any]:
+    summary = report["summary"]
+    return {
+        "files_scanned": summary["files_scanned"],
+        "file_failures": summary["file_failures"],
+        "function_failures": summary["function_failures"],
+        "failing_paths": sorted(item["path"] for item in report["largest_files"]
+                                if item["status"] == "fail"),
+    }
+
+
+def _suffixes(config: dict[str, Any]) -> list[str]:
+    suffixes = sorted(set(config["paths"]["include_extensions"]))
+    assert suffixes, "the shipped config reads no suffixes; this sweep would pass vacuously"
+    return suffixes
+
+
+def test_ignored_untracked_build_output_leaves_the_score_and_is_counted(tmp_path) -> None:
+    from maintainability_audit.report import build_report
+
+    config = _config()
+    repo = _repo(tmp_path)
+    before = _scored(build_report(repo, config, run_analyzers=False))
+
+    suffixes = _suffixes(config)
+    for index, suffix in enumerate(suffixes):
+        _failing_file(repo / "out" / "classes" / f"artifact{index}{suffix}", config)
+    after = build_report(repo, config, run_analyzers=False)
+
+    assert _scored(after) == before, (
+        "ignored, untracked build output changed the scored population: "
+        f"before={before} after={_scored(after)}"
+    )
+    assert after["summary"]["generated_files"] == len(suffixes), (
+        f"{len(suffixes)} build-output files left the score but "
+        f"{after['summary']['generated_files']} were counted"
+    )
+    owners = {entry["path"]: entry["evidence"] for entry in after["summary"]["classifications"]}
+    assert "out" in owners and ".gitignore" in owners["out"], owners
+
+
+def test_a_tracked_file_under_an_ignore_rule_is_still_scored(tmp_path) -> None:
+    """Git tracking it is the repository saying it is source, whatever the rule matches.
+
+    Covers existing behaviour: before D175 nothing read the ignore rules, so a
+    force-added file was scored then too. It guards the fix against treating
+    a pattern match as the verdict.
+    """
+    from maintainability_audit.report import build_report
+
+    config = _config()
+    repo = _repo(tmp_path)
+    _failing_file(repo / "out" / "Kept.java", config)
+    _git(repo, "add", "-f", "out/Kept.java")
+    report = build_report(repo, config, run_analyzers=False)
+    assert "out/Kept.java" in _scored(report)["failing_paths"]
+
+
+def test_an_untracked_file_nothing_ignores_is_still_scored(tmp_path) -> None:
+    """Uncommitted work stays visible (D56); only ignored paths leave.
+
+    Covers existing behaviour: untracked files were scored before D175, and
+    this pins that the fix keys on the ignore rule, not on being untracked.
+    """
+    from maintainability_audit.report import build_report
+
+    config = _config()
+    repo = _repo(tmp_path)
+    _failing_file(repo / "src" / "draft.py", config)
+    report = build_report(repo, config, run_analyzers=False)
+    assert "src/draft.py" in _scored(report)["failing_paths"]
+
+
+def test_a_personal_global_ignore_file_does_not_change_the_score(tmp_path, monkeypatch) -> None:
+    """Only the repository's own `.gitignore` decides — never one machine's (P1).
+
+    `--exclude-standard` would read the user's `core.excludesFile`, so two
+    laptops with different global ignores would score one commit differently.
+
+    Covers existing behaviour: before D175 no ignore file was read, global or
+    not; this guards the fix against reading the wrong one.
+    """
+    from maintainability_audit.report import build_report
+
+    config = _config()
+    repo = _repo(tmp_path)
+    _failing_file(repo / "src" / "personal.py", config)
+    global_ignore = tmp_path / "global-ignore"
+    global_ignore.write_text("personal.py\n", encoding="utf-8")
+    global_config = tmp_path / "global-gitconfig"
+    global_config.write_text(f"[core]\n\texcludesFile = {global_ignore}\n", encoding="utf-8")
+    monkeypatch.setenv("GIT_CONFIG_GLOBAL", str(global_config))
+
+    report = build_report(repo, config, run_analyzers=False)
+    assert "src/personal.py" in _scored(report)["failing_paths"], (
+        "a path ignored only by this machine's global excludes left the score"
+    )
+
+
+def test_a_tree_git_cannot_read_is_scored_as_it_always_was(tmp_path) -> None:
+    """No repository, no evidence: nothing leaves.
+
+    Covers existing behaviour: a non-git tree had no ignore evidence before
+    D175 either; this guards that a failing git query is not read as a verdict.
+    """
+    from maintainability_audit.report import build_report
+
+    config = _config()
+    tree = tmp_path / "tree"
+    (tree / "src").mkdir(parents=True)
+    (tree / ".gitignore").write_text("out/\n", encoding="utf-8")
+    _failing_file(tree / "out" / "artifact.html", config)
+    report = build_report(tree, config, run_analyzers=False)
+    assert "out/artifact.html" in _scored(report)["failing_paths"]