maintainability-agent 4.4.2__tar.gz → 4.4.3__tar.gz

{maintainability_agent-4.4.2/src/maintainability_agent.egg-info → maintainability_agent-4.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 4.4.2
+Version: 4.4.3
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -47,7 +47,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 **4.4.2**.
+Version **4.4.3**.
 
 > ## **Calibrated against 201 mature open-source repositories in fifteen languages.**
 >
@@ -517,7 +517,7 @@ instead of an invokable skill:
 This repo ships `action.yml`, usable as a composite action:
 
 ```yaml
-- uses: marshallguillory86/maintainability-agent@v4.4.2
+- uses: marshallguillory86/maintainability-agent@v4.4.3
   with:
     config: maintainability-agent.json
     changed-only: main...HEAD

{maintainability_agent-4.4.2 → maintainability_agent-4.4.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 **4.4.2**.
+Version **4.4.3**.
 
 > ## **Calibrated against 201 mature open-source repositories in fifteen languages.**
 >
@@ -475,7 +475,7 @@ instead of an invokable skill:
 This repo ships `action.yml`, usable as a composite action:
 
 ```yaml
-- uses: marshallguillory86/maintainability-agent@v4.4.2
+- uses: marshallguillory86/maintainability-agent@v4.4.3
   with:
     config: maintainability-agent.json
     changed-only: main...HEAD

{maintainability_agent-4.4.2 → maintainability_agent-4.4.3/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 4.4.2
+Version: 4.4.3
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -47,7 +47,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 **4.4.2**.
+Version **4.4.3**.
 
 > ## **Calibrated against 201 mature open-source repositories in fifteen languages.**
 >
@@ -517,7 +517,7 @@ instead of an invokable skill:
 This repo ships `action.yml`, usable as a composite action:
 
 ```yaml
-- uses: marshallguillory86/maintainability-agent@v4.4.2
+- uses: marshallguillory86/maintainability-agent@v4.4.3
   with:
     config: maintainability-agent.json
     changed-only: main...HEAD

{maintainability_agent-4.4.2 → maintainability_agent-4.4.3}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ src/maintainability_audit/_mcp_gate.py
 src/maintainability_audit/_mcp_grants.py
 src/maintainability_audit/_mcp_refusals.py
 src/maintainability_audit/_mcp_resources.py
+src/maintainability_audit/_mcp_servers.py
 src/maintainability_audit/_mcp_setup.py
 src/maintainability_audit/_metric_adapters.py
 src/maintainability_audit/_metrics_types.py
@@ -342,6 +343,7 @@ tests/test_mcp_baseline_payload.py
 tests/test_mcp_format_contract.py
 tests/test_mcp_history.py
 tests/test_mcp_server.py
+tests/test_mcp_servers.py
 tests/test_mcp_start_failure_names_what_is_installed.py
 tests/test_migration_1_0.py
 tests/test_missing_security_scanners_are_named_before_the_run.py

{maintainability_agent-4.4.2 → maintainability_agent-4.4.3}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "4.4.2"
+__version__ = "4.4.3"

maintainability_agent-4.4.3/src/maintainability_audit/_mcp_servers.py

@@ -0,0 +1,107 @@
+"""Which MCP servers are running which version, so ``--update`` can stop stale ones.
+
+A stdio MCP server holds the code it loaded at spawn. After an upgrade it
+keeps serving the old version until it stops, and its host starts the new
+one on the next call. 4.4.2 told the operator to run ``/mcp``, which in the
+VS Code panel only lists servers (D232). Now each server records its pid and
+version here, marks itself busy while an audit runs, and ``--update`` stops
+the stale ones that are idle. A busy server is left alone; the next hourly
+update stops it.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+
+from . import _runner
+
+
+@dataclass(frozen=True)
+class Stopped:
+    stopped: tuple[int, ...] = ()
+    busy: tuple[int, ...] = ()
+    gone: tuple[int, ...] = ()
+
+
+def _servers(home: Path) -> Path:
+    return home / ".local" / "share" / "maintainability-agent" / "servers"
+
+
+def register(home: Path, pid: int, version: str) -> Path:
+    folder = _servers(home)
+    folder.mkdir(parents=True, exist_ok=True)
+    record = folder / f"{pid}.json"
+    record.write_text(json.dumps({"pid": pid, "version": version}) + "\n", encoding="utf-8")
+    return record
+
+
+def unregister(home: Path, pid: int) -> None:
+    (_servers(home) / f"{pid}.json").unlink(missing_ok=True)
+
+
+@contextmanager
+def busy(home: Path, pid: int) -> Iterator[None]:
+    folder = _servers(home)
+    folder.mkdir(parents=True, exist_ok=True)
+    marker = folder / f"{pid}.busy"
+    marker.touch()
+    try:
+        yield
+    finally:
+        marker.unlink(missing_ok=True)
+
+
+def _alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def _is_server(pid: int) -> bool:
+    """The pid is still an MA MCP server, not a reused pid of something else."""
+    result = _runner.run("mcp-servers", _runner.Invocation(argv=("ps", "-o", "command=", "-p", str(pid))),
+                         timeout_seconds=10)
+    command = result.stdout or ""
+    return "maintainability" in command and "mcp" in command
+
+
+def stop_stale(home: Path, installed: str, *,
+               alive: Callable[[int], bool] = _alive,
+               is_server: Callable[[int], bool] = _is_server,
+               kill: Callable[[int, int], None] = os.kill) -> Stopped:
+    folder = _servers(home)
+    stopped: list[int] = []
+    held: list[int] = []
+    gone: list[int] = []
+    for record in sorted(folder.glob("*.json")) if folder.is_dir() else []:
+        try:
+            data = json.loads(record.read_text(encoding="utf-8"))
+            pid, version = int(data["pid"]), str(data["version"])
+        except (OSError, ValueError, KeyError, TypeError):
+            record.unlink(missing_ok=True)
+            continue
+        if version == installed:
+            continue
+        if not alive(pid):
+            record.unlink(missing_ok=True)
+            gone.append(pid)
+        elif (folder / f"{pid}.busy").exists():
+            held.append(pid)
+        elif not is_server(pid):
+            record.unlink(missing_ok=True)
+            gone.append(pid)
+        else:
+            kill(pid, signal.SIGTERM)
+            record.unlink(missing_ok=True)
+            stopped.append(pid)
+    return Stopped(tuple(stopped), tuple(held), tuple(gone))

{maintainability_agent-4.4.2 → maintainability_agent-4.4.3}/src/maintainability_audit/_self_update.py

@@ -12,7 +12,8 @@ backwards — so this module holds no HTTP client and reads no release feed
 acquisition). Every child process goes through ``_runner.run`` (rule 7). A
 version that comes back lower than before is reported, never accepted
 silently; a higher one re-syncs the skill and records that the MCP server,
-which holds the code it loaded at spawn, needs a restart.
+which holds the code it loaded at spawn, needs a restart; stale servers
+that are not mid-audit are stopped so their host restarts them (D232).
 """
 
 from __future__ import annotations
@@ -23,7 +24,7 @@ import sys
 from dataclasses import dataclass
 from pathlib import Path
 
-from . import _runner
+from . import _mcp_servers, _runner
 
 PACKAGE = "maintainability-agent"
 #: The launch agent, named for the product and the component (reverse DNS of
@@ -81,14 +82,28 @@ def update(python: str, uv: str | None, home: Path) -> UpdateResult:
                             f"version went down from {before} to {after}",
                             f"Refused: the install moved {before} to {after}, a downgrade.")
     if _key(after) == _key(before):
-        return UpdateResult(before, after, False, False, None, f"Already up to date ({after}).")
+        return UpdateResult(before, after, False, False, None,
+                            f"Already up to date ({after}).{_servers_note(home, after)}")
     _run([python, "-m", "maintainability_audit", "--install-skill"])
     state = _state_dir(home)
     state.mkdir(parents=True, exist_ok=True)
     (state / ".pending-restart").write_text(after + "\n", encoding="utf-8")
     return UpdateResult(before, after, True, True, None,
-                        f"Updated {before} -> {after}; skill re-synced. "
-                        "Restart the MCP server to use it (/mcp in Claude Code).")
+                        f"Updated {before} -> {after}; skill re-synced.{_servers_note(home, after)}")
+
+
+def _servers_note(home: Path, installed: str) -> str:
+    """Stop the MCP servers still on an older version (D232) and say so.
+    A host starts a stopped stdio server again on its next call."""
+    result = _mcp_servers.stop_stale(home, installed)
+    note = ""
+    if result.stopped:
+        note += (f" Stopped {len(result.stopped)} MCP server(s) on an older version;"
+                 f" the host starts {installed} on its next call.")
+    if result.busy:
+        note += (f" {len(result.busy)} busy with an audit kept running;"
+                 " the next update stops it.")
+    return note
 
 
 def update_action() -> int:

{maintainability_agent-4.4.2 → maintainability_agent-4.4.3}/src/maintainability_audit/mcp_server.py

@@ -16,9 +16,11 @@ string, or invokes a shell.
 from __future__ import annotations
 
 import argparse
+import os
 from pathlib import Path
 from typing import Any
 
+from . import _mcp_servers
 from ._catalog import PolicyError as PolicyError
 
 # Redundant aliases on purpose: every name the split moved to
@@ -263,21 +265,23 @@ def _run_audit_tool(ledger, tool_error, repository_root, config_path, changed_on
     """
     try:
         _apply_call_consents(ledger, repository_root, setup, grant, setup_answers)
-        return audit_repository(
-            repository_root,
-            config_path,
-            changed_only,
-            run_analyzers,
-            format,
-            record_history,
-            baseline_path,
-            write_baseline,
-            include_prompt,
-            # Interactive door never assumes go (D27); CLI default is "run".
-            action=action,
-            roots=ledger.current(),
-            output_path=output_path,
-        )
+        # Busy while auditing: `--update` never stops a server mid-audit (D232).
+        with _mcp_servers.busy(Path.home(), os.getpid()):
+            return audit_repository(
+                repository_root,
+                config_path,
+                changed_only,
+                run_analyzers,
+                format,
+                record_history,
+                baseline_path,
+                write_baseline,
+                include_prompt,
+                # Interactive door never assumes go (D27); CLI default is "run".
+                action=action,
+                roots=ledger.current(),
+                output_path=output_path,
+            )
     except ANTICIPATED_REFUSALS as refusal:
         raise tool_error(str(refusal)) from refusal
 
@@ -548,7 +552,12 @@ def _parser() -> argparse.ArgumentParser:
 
 def main(argv: list[str] | None = None) -> int:
     args = _parser().parse_args(argv)
-    create_server(roots=allowed_roots(tuple(args.allow_root))).run("stdio")
+    # Recorded so `--update` can stop this server once it is stale (D232).
+    _mcp_servers.register(Path.home(), os.getpid(), VERSION)
+    try:
+        create_server(roots=allowed_roots(tuple(args.allow_root))).run("stdio")
+    finally:
+        _mcp_servers.unregister(Path.home(), os.getpid())
     return 0
 
 

maintainability_agent-4.4.3/tests/test_mcp_servers.py

@@ -0,0 +1,191 @@
+"""D232: running MCP servers are registered so ``--update`` can stop stale ones.
+
+Written by the Claude Sonnet test seat (Codex at its usage limit); Codex reviews.
+After an upgrade the old server kept serving old code and /mcp reloads
+nothing. ``_mcp_servers`` keeps one record per server under
+``<home>/.local/share/maintainability-agent/servers`` and stops, by SIGTERM,
+those running an older version that are not mid-audit.
+
+Seams: ``alive``, ``is_server`` and ``kill`` are injected fakes, so no real
+process is signalled. ``home`` is always ``tmp_path``.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+import os
+import signal
+from pathlib import Path
+
+import pytest
+
+from maintainability_audit import mcp_server
+
+
+def _ms():
+    return importlib.import_module("maintainability_audit._mcp_servers")
+
+
+def _servers(home: Path) -> Path:
+    return home / ".local" / "share" / "maintainability-agent" / "servers"
+
+
+class _Kill:
+    def __init__(self) -> None:
+        self.calls: list[tuple[int, int]] = []
+
+    def __call__(self, pid: int, sig: int) -> None:
+        self.calls.append((pid, sig))
+
+
+def _stop(home: Path, installed: str, *, alive=True, server=True):
+    kill = _Kill()
+    result = _ms().stop_stale(home, installed, alive=lambda pid: alive,
+                              is_server=lambda pid: server, kill=kill)
+    return result, kill
+
+
+def test_register_writes_pid_and_version(tmp_path) -> None:
+    path = _ms().register(tmp_path, 4242, "4.4.0")
+    assert path == _servers(tmp_path) / "4242.json"
+    assert json.loads(path.read_text(encoding="utf-8")) == {"pid": 4242, "version": "4.4.0"}
+
+
+def test_unregister_removes_record_and_tolerates_absence(tmp_path) -> None:
+    ms = _ms()
+    path = ms.register(tmp_path, 7, "1.0.0")
+    ms.unregister(tmp_path, 7)
+    assert not path.exists()
+    ms.unregister(tmp_path, 7)  # absent: no error
+
+
+def test_busy_marker_exists_only_inside_block(tmp_path) -> None:
+    marker = _servers(tmp_path) / "9.busy"
+    with _ms().busy(tmp_path, 9):
+        assert marker.exists()
+    assert not marker.exists()
+
+
+def test_busy_marker_removed_when_body_raises(tmp_path) -> None:
+    marker = _servers(tmp_path) / "9.busy"
+    with pytest.raises(RuntimeError), _ms().busy(tmp_path, 9):
+        raise RuntimeError("audit blew up")
+    assert not marker.exists()
+
+
+def test_stale_live_server_is_sigtermed_and_record_removed(tmp_path) -> None:
+    ms = _ms()
+    path = ms.register(tmp_path, 100, "4.4.0")
+    result, kill = _stop(tmp_path, "4.5.0")
+    assert kill.calls == [(100, signal.SIGTERM)]
+    assert result.stopped == (100,) and result.busy == () and result.gone == ()
+    assert not path.exists()
+
+
+def test_current_version_server_is_untouched(tmp_path) -> None:
+    path = _ms().register(tmp_path, 100, "4.5.0")
+    result, kill = _stop(tmp_path, "4.5.0")
+    assert kill.calls == []
+    assert (result.stopped, result.busy, result.gone) == ((), (), ())
+    assert path.exists()
+
+
+def test_dead_pid_record_is_removed_and_reported_gone(tmp_path) -> None:
+    path = _ms().register(tmp_path, 100, "4.4.0")
+    result, kill = _stop(tmp_path, "4.5.0", alive=False)
+    assert kill.calls == []
+    assert result.gone == (100,)
+    assert not path.exists()
+
+
+def test_busy_server_is_left_alone_and_reported_busy(tmp_path) -> None:
+    ms = _ms()
+    path = ms.register(tmp_path, 100, "4.4.0")
+    with ms.busy(tmp_path, 100):
+        result, kill = _stop(tmp_path, "4.5.0")
+    assert kill.calls == []
+    assert result.busy == (100,) and result.stopped == ()
+    assert path.exists()
+
+
+def test_reused_pid_is_never_killed(tmp_path) -> None:
+    path = _ms().register(tmp_path, 100, "4.4.0")
+    result, kill = _stop(tmp_path, "4.5.0", server=False)
+    assert kill.calls == []
+    assert result.gone == (100,) and result.stopped == ()
+    assert not path.exists()
+
+
+def test_garbage_record_is_removed_without_crashing(tmp_path) -> None:
+    ms = _ms()
+    ms.register(tmp_path, 1, "4.4.0")  # makes the directory
+    bad = _servers(tmp_path) / "555.json"
+    bad.write_text("{not json", encoding="utf-8")
+    result, kill = _stop(tmp_path, "4.5.0")
+    assert not bad.exists()
+    assert 555 not in result.stopped
+    assert (555, signal.SIGTERM) not in kill.calls
+
+
+def test_stop_stale_without_servers_dir_is_empty(tmp_path) -> None:
+    result, kill = _stop(tmp_path, "4.5.0")
+    assert (result.stopped, result.busy, result.gone) == ((), (), ())
+    assert kill.calls == []
+
+
+# mcp_server wiring ---------------------------------------------------------
+
+def test_main_registers_during_run_and_unregisters_after(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    record = _servers(tmp_path) / f"{os.getpid()}.json"
+    seen: dict = {}
+
+    class _Stub:
+        def run(self, transport: str) -> None:
+            seen["during"] = json.loads(record.read_text(encoding="utf-8"))
+
+    monkeypatch.setattr(mcp_server, "create_server", lambda **_kw: _Stub())
+    assert mcp_server.main(["--allow-root", str(tmp_path)]) == 0
+    assert seen["during"] == {"pid": os.getpid(), "version": mcp_server.VERSION}
+    assert not record.exists()
+
+
+def test_main_unregisters_when_run_raises(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    record = _servers(tmp_path) / f"{os.getpid()}.json"
+
+    seen: dict = {}
+
+    class _Stub:
+        def run(self, transport: str) -> None:
+            seen["registered"] = record.exists()
+            raise RuntimeError("transport died")
+
+    monkeypatch.setattr(mcp_server, "create_server", lambda **_kw: _Stub())
+    with pytest.raises(RuntimeError):
+        mcp_server.main(["--allow-root", str(tmp_path)])
+    assert seen["registered"] is True
+    assert not record.exists()
+
+
+def test_audit_tool_holds_busy_marker_while_auditing(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    marker = _servers(tmp_path) / f"{os.getpid()}.busy"
+    seen: dict = {}
+
+    def fake_audit(*_args, **_kwargs):
+        seen["busy"] = marker.exists()
+        return {"audit_ran": False}
+
+    class _Ledger:
+        def current(self):
+            return ()
+
+    monkeypatch.setattr(mcp_server, "audit_repository", fake_audit)
+    monkeypatch.setattr(mcp_server, "_apply_call_consents", lambda *a, **k: None)
+    mcp_server._run_audit_tool(
+        _Ledger(), RuntimeError, str(tmp_path), None, None, None, None, None,
+        None, False, True, "run", None, None, None)
+    assert seen["busy"] is True
+    assert not marker.exists()

{maintainability_agent-4.4.2 → maintainability_agent-4.4.3}/tests/test_self_update.py

@@ -159,6 +159,7 @@ def test_version_order_is_numeric_not_lexical(fake, tmp_path) -> None:
 # 5 -- upgrade --------------------------------------------------------------
 
 def test_upgrade_syncs_skill_writes_marker_and_says_restart(fake, tmp_path) -> None:
+    """Covers existing behaviour: skill sync and marker (the "/mcp" assertion moved to D232)."""
     runner = fake(["4.4.0", "4.5.0"])
     result = _su().update(PY, UV, tmp_path)
     assert [PY, "-m", "maintainability_audit", "--install-skill"] in [
@@ -167,7 +168,65 @@ def test_upgrade_syncs_skill_writes_marker_and_says_restart(fake, tmp_path) -> N
     assert result.restart_needed is True
     assert not result.error
     assert _marker(tmp_path).read_text(encoding="utf-8").strip() == "4.5.0"
-    assert "/mcp" in result.message
+
+
+# 5b -- D232: stop stale MCP servers --------------------------------------
+
+def _stopper(monkeypatch, *, stopped=(), busy=(), gone=()):
+    """Replace ``_mcp_servers.stop_stale`` with a fake returning fixed pids."""
+    ms = importlib.import_module("maintainability_audit._mcp_servers")
+    calls = []
+
+    def fake_stop(home, installed, **kwargs):
+        calls.append((home, installed))
+        return ms.Stopped(stopped=tuple(stopped), busy=tuple(busy), gone=tuple(gone))
+
+    monkeypatch.setattr(ms, "stop_stale", fake_stop)
+    return calls
+
+
+def test_upgrade_stops_stale_servers_and_says_so(fake, tmp_path, monkeypatch) -> None:
+    """D232: the message reports the stop and never points at /mcp."""
+    fake(["4.4.0", "4.5.0"])
+    calls = _stopper(monkeypatch, stopped=(101,))
+    message = _su().update(PY, UV, tmp_path).message
+    assert calls == [(tmp_path, "4.5.0")]
+    assert "Stopped 1" in message and "next call" in message
+    assert "/mcp" not in message
+
+
+def test_upgrade_with_busy_server_says_next_update_stops_it(fake, tmp_path,
+                                                            monkeypatch) -> None:
+    """D232: a mid-audit server is skipped and named as busy."""
+    fake(["4.4.0", "4.5.0"])
+    _stopper(monkeypatch, busy=(202,))
+    message = _su().update(PY, UV, tmp_path).message
+    assert "1 busy" in message and "next update" in message
+    assert "/mcp" not in message
+
+
+def test_upgrade_message_never_mentions_mcp_command_with_no_servers(
+        fake, tmp_path, monkeypatch) -> None:
+    """D232: even with nothing to stop, the old /mcp advice is gone."""
+    fake(["4.4.0", "4.5.0"])
+    _stopper(monkeypatch)
+    assert "/mcp" not in _su().update(PY, UV, tmp_path).message
+
+
+def test_already_up_to_date_still_stops_stale_servers(fake, tmp_path, monkeypatch) -> None:
+    """D232: a server left behind by an earlier upgrade is stopped by a later no-op update."""
+    fake(["4.5.0", "4.5.0"])
+    calls = _stopper(monkeypatch, stopped=(101,))
+    _su().update(PY, UV, tmp_path)
+    assert calls == [(tmp_path, "4.5.0")]
+
+
+def test_up_to_date_with_nothing_stale_message_unchanged(fake, tmp_path,
+                                                         monkeypatch) -> None:
+    """D232: nothing stale keeps the plain message."""
+    fake(["4.5.0", "4.5.0"])
+    _stopper(monkeypatch)
+    assert _su().update(PY, UV, tmp_path).message == "Already up to date (4.5.0)."
 
 
 # 6 -- up to date -----------------------------------------------------------