Ensure that harness install still deletes correct files

Author: rxdt

harness/cli.py

@@ -176,14 +176,14 @@ def cleanup(cwd: Path) -> bool:
     Returns:
         bool True if successful
     """
-    if not ((cwd / "README.template.md").is_file() and (cwd / "temp.pyproject.toml").is_file()):
+    if not ((cwd / "README.template.md").is_file() and (cwd / "harness" / "temp.pyproject.toml").is_file()):
         return False
     clean_tree = not run_git(["status", "--porcelain"], cwd).strip()
     (cwd / "README.template.md").replace(cwd / "README.md")
-    (cwd / "temp.pyproject.toml").replace(cwd / "pyproject.toml")
-    for file_name in (".github/workflows/publish.yml", "CONTRIBUTING.md"):
+    (cwd / "harness" / "temp.pyproject.toml").replace(cwd / "pyproject.toml")
+    for file_name in ("mutation-score.json", ".github/workflows/publish.yml", "CONTRIBUTING.md"):
         (cwd / file_name).unlink(missing_ok=True)
-    for directory in (cwd / "dist", cwd / "harness" / "tests", cwd / ".assets"):
+    for directory in (cwd / "harness" / "tests", cwd / ".assets", cwd / ".*cache"):
         if directory.exists():
             rmtree(directory)
     if run_git(["rev-parse", "--short", "HEAD"], cwd).startswith("867f2df") and clean_tree:

harness/temp.pyproject.toml

@@ -93,9 +93,7 @@ security = [
     ".",
 ]
 types = ["pyright", "--outputjson"]
-test = [
-    "pytest", "-p", "no:cacheprovider", "-n", "auto", "--cov", "--cov-report=term-missing", "--cov-fail-under=100", "--hypothesis-show-statistics",
-]
+test = ["pytest", "-p", "no:cacheprovider", "-n", "auto", "--cov", "--cov-report=term-missing", "--cov-fail-under=100", "--durations=5"]
 
 [tool.harness.FORBIDDEN]
 DIRS = ["harness/", ".githooks/", ".github/", ".git/", "preferences/", "tests/preferences/", "mutation", "tests/mutation/"]

harness/tests/test_cli.py

@@ -870,151 +870,121 @@ def test_hoist_aborts_before_writing_when_declined(monkeypatch: pytest.MonkeyPat
 
 
 def test_installing_the_template_cleans_the_repo_and_sets_hooks(
-    monkeypatch: pytest.MonkeyPatch, git_repo: Path
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    """Install cleans template files, syncs dependencies, activates hooks, and is idempotent."""
-    (git_repo / "pyproject.toml").write_text(
-        "[project]\n"
-        'name = "old-name"\n'
-        'version = "2.3.4"\n'
-        'description = "the user\'s own project"\n'
-        'authors = [{ name = "someone" }]\n'
-        'requires-python = ">=3.11"\n'
-        "\n[project.scripts]\n"
-        'harness = "harness.cli:main"\n'
-        "\n[tool.pyright]\n"
-        'typeCheckingMode = "strict"\n'
-        'include = ["src", "harness"]\n'
-        "\n[tool.pytest.ini_options]\n"
-        'addopts = ["-ra"]\n'
-        'testpaths = ["tests", "harness"]\n'
-        'pythonpath = ["src", "harness"]\n'
-        "\n[tool.coverage]\n"
-        'run.source = ["src", "harness"]\n'
-        "report.fail_under = 100\n"
-        "\n[tool.complexipy]\n"
-        'paths = ["src", "harness"]\n'
-        "max-complexity-allowed = 10\n"
-        "\n[tool.ruff]\n"
-        'exclude = [".git"]\n'
-        "\n[tool.pylint.main]\n"
-        'ignore = [".git"]\n',
-        encoding="utf-8",
+    """Install a fresh template checkout with real process, filesystem, and Git boundaries."""
+    template_repo = tmp_path / "template"
+    subprocess.run(
+        ["git", "clone", "--quiet", "--shared", str(REPO_ROOT), str(template_repo)],
+        check=True,
     )
-    (git_repo / "uv.lock").touch()
-    replacement_project = "[project]\nname = 'replacement'\n"
-    (git_repo / "temp.pyproject.toml").write_text(replacement_project, encoding="utf-8")
-    template_files = (".banner.svg", ".diagram.png", ".infin.png", ".loops_agents.svg", ".loops.svg")
-    (git_repo / ".assets").mkdir()
-    for file_name in template_files:
-        (git_repo / ".assets" / file_name).touch()
-    (git_repo / ".github" / "workflows").mkdir(parents=True)
-    (git_repo / ".github" / "workflows" / "publish.yml").touch()
-    (git_repo / "CONTRIBUTING.md").touch()
-    (git_repo / "dist").mkdir()
-    (git_repo / "dist" / "stale.whl").touch()
-    for directory in ("harness/tests", "preferences", "tests/preferences"):
-        (git_repo / directory).mkdir(parents=True)
-    monkeypatch.setattr(cli, "which", which_finds(("timeout",)))
-    monkeypatch.setattr(cli, "REPO_ROOT_STR", str(git_repo))
-    toolchain = stub_toolchain(git_repo / ".git")
-    monkeypatch.setattr(subprocess, "run", toolchain)
+    expected_project = (template_repo / "harness" / "temp.pyproject.toml").read_text(encoding="utf-8")
+    env_bin = template_repo / ".venv" / ("Scripts" if sys.platform == "win32" else "bin")
+    monkeypatch.setattr(cli, "REPO_ROOT", template_repo)
+    monkeypatch.setattr(cli, "REPO_ROOT_STR", str(template_repo))
+    monkeypatch.setattr(gates(), "repo_root", template_repo)
+    monkeypatch.setattr(cli, "infer_env_manager", Mock(return_value=(env_bin, ["uv", "sync"])))
+    monkeypatch.setattr(cli, "check_for_timeout_and_prompt", Mock(return_value="timeout"))
+    binary = harness_executable(env_bin)
+    binary.parent.mkdir(parents=True)
+    binary.touch()
+    run = Mock(
+        wraps=subprocess.run,
+        side_effect=[subprocess.CompletedProcess(("uv", "sync"), 0), *([DEFAULT] * 8)],
+    )
+    monkeypatch.setattr(subprocess, "run", run)
 
-    monkeypatch.setattr(Path, "is_file", create_autospec(Path.is_file, wraps=Path.is_file))
-    monkeypatch.setattr(Path, "replace", create_autospec(Path.replace, wraps=Path.replace))
-    monkeypatch.setattr(Path, "unlink", create_autospec(Path.unlink, wraps=Path.unlink))
-    monkeypatch.setattr(cli, "rmtree", Mock(wraps=cli.rmtree))
     result = runner.invoke(cli.app, ["install"])
 
-    assert result.exit_code == 0
-    assert (git_repo / "pyproject.toml").read_text(encoding="utf-8") == replacement_project
-    assert not (git_repo / "temp.pyproject.toml").exists()
-    assert (git_repo / "README.md").read_text(encoding="utf-8") == "seed\n"
-    assert not (git_repo / "README.template.md").exists()
-    assert not (git_repo / ".assets").exists()
-    assert not (git_repo / ".github" / "workflows" / "publish.yml").exists()
-    assert not (git_repo / "CONTRIBUTING.md").exists()
-    assert not (git_repo / "dist").exists()
-    assert not (git_repo / "harness" / "tests").exists()
-    assert (git_repo / "preferences").is_dir()
-    assert (git_repo / "tests" / "preferences").is_dir()
-    Path.is_file.assert_any_call(git_repo / "README.template.md")
-    Path.is_file.assert_any_call(git_repo / "temp.pyproject.toml")
-    Path.replace.assert_any_call(git_repo / "README.template.md", git_repo / "README.md")
-    Path.replace.assert_any_call(git_repo / "temp.pyproject.toml", git_repo / "pyproject.toml")
-    Path.unlink.assert_any_call(git_repo / ".github" / "workflows" / "publish.yml", missing_ok=True)
-    Path.unlink.assert_any_call(git_repo / "CONTRIBUTING.md", missing_ok=True)
-    cli.rmtree.assert_any_call(git_repo / "dist")
-    cli.rmtree.assert_any_call(git_repo / "harness" / "tests")
-    cli.rmtree.assert_any_call(git_repo / ".assets")
-    toolchain.assert_any_call(("uv", "sync"), cwd=str(git_repo), check=True)
-    recorded_harness = (git_repo / ".git" / "harness-path").read_text(encoding="utf-8").strip()
-    env_bin = git_repo / ".venv" / ("Scripts" if sys.platform == "win32" else "bin")
+    assert result.exit_code == 0, result.output
+    assert run.call_args_list[0] == call(("uv", "sync"), cwd=str(template_repo), check=True)
+    recorded_harness = (template_repo / ".git" / "harness-path").read_text(encoding="utf-8").strip()
     assert normalized_path(recorded_harness) == normalized_path(harness_executable(env_bin))
-    toolchain.assert_any_call(
-        ["git", "config", "core.hooksPath", ".githooks"], cwd=cli.REPO_ROOT_STR, check=True
-    )
-
-    head = gate.run_git(["rev-parse", "HEAD"], git_repo)
-    status = gate.run_git(["status", "--porcelain"], git_repo)
-    generated_project = (git_repo / "pyproject.toml").read_text(encoding="utf-8")
-    again = runner.invoke(cli.app, ["install"])
-
-    assert again.exit_code == 0
-    assert gate.run_git(["rev-parse", "HEAD"], git_repo) == head
-    assert gate.run_git(["status", "--porcelain"], git_repo) == status
-    assert (git_repo / "pyproject.toml").read_text(encoding="utf-8") == generated_project
-    assert (git_repo / "README.md").read_text(encoding="utf-8") == "seed\n"
+    assert gate.run_git(["config", "--get", "core.hooksPath"], template_repo).strip() == ".githooks"
+    assert (template_repo / "preferences").is_dir()
+    assert (template_repo / "tests" / "preferences").is_dir()
+
+    leftovers = [
+        name
+        for name in (
+            "README.template.md",
+            ".assets",
+            ".github/workflows/publish.yml",
+            "CONTRIBUTING.md",
+            "mutation-score.json",
+            "harness/tests",
+        )
+        if (template_repo / name).exists()
+    ]
+    assert (template_repo / "pyproject.toml").read_text(encoding="utf-8") == expected_project
+    assert not leftovers, f"template leftovers after install: {leftovers}"
 
 
 def test_cleanup_updates_the_pristine_historical_template_commit(
     monkeypatch: pytest.MonkeyPatch, git_repo: Path
 ) -> None:
-    """The historical pristine-template probes trigger the real Git commit update after real cleanup."""
+    """Historical identity amends a real pristine repository without requiring old Git history."""
+    replacement_project = (REPO_ROOT / "harness" / "temp.pyproject.toml").read_text(encoding="utf-8")
+    replacement_readme = "replacement project readme\n"
     (git_repo / "pyproject.toml").write_text('[project]\nname = "template"\n', encoding="utf-8")
-    replacement_project = "[project]\nname = 'replacement'\n"
-    (git_repo / "temp.pyproject.toml").write_text(replacement_project, encoding="utf-8")
-    replacement_readme = "the project readme\n"
     (git_repo / "README.template.md").write_text(replacement_readme, encoding="utf-8")
-    real_run_git = cli.run_git
-    run_git = Mock(wraps=real_run_git, side_effect=["", "867f2df", DEFAULT])
+    (git_repo / "harness").mkdir()
+    (git_repo / "harness" / "temp.pyproject.toml").write_text(replacement_project, encoding="utf-8")
+    gate.run_git(["add", "-A"], git_repo)
+    gate.run_git(["commit", "-q", "-m", "template state"], git_repo)
+    assert not gate.run_git(["status", "--porcelain"], git_repo)
+    parent = gate.run_git(["rev-parse", "HEAD^"], git_repo).strip()
+    original_head = gate.run_git(["rev-parse", "HEAD"], git_repo).strip()
+    original_message = gate.run_git(["log", "-1", "--format=%B"], git_repo).strip()
+    run_git = Mock(wraps=cli.run_git, side_effect=[DEFAULT, "867f2df\n", DEFAULT])
     monkeypatch.setattr(cli, "run_git", run_git)
 
     assert cli.cleanup(git_repo) is True
-    assert run_git.call_args_list[:2] == [
-        call(["status", "--porcelain"], git_repo),
-        call(["rev-parse", "--short", "HEAD"], git_repo),
-    ]
-    wrong_repo_amend = call(["commit", "-a", "--amend", "--no-edit"])
-    correct_repo_amend = call(["commit", "-a", "--amend", "--no-edit"], git_repo)
-    assert run_git.call_args_list[-1] != wrong_repo_amend
-    assert run_git.call_args_list[-1] == correct_repo_amend
+
+    amended_head = gate.run_git(["rev-parse", "HEAD"], git_repo).strip()
+    assert amended_head != original_head
+    assert gate.run_git(["rev-parse", "HEAD^"], git_repo).strip() == parent
+    assert gate.run_git(["log", "-1", "--format=%B"], git_repo).strip() == original_message
+    assert not gate.run_git(["status", "--porcelain"], git_repo)
     assert (git_repo / "README.md").read_text(encoding="utf-8") == replacement_readme
     assert (git_repo / "pyproject.toml").read_text(encoding="utf-8") == replacement_project
-    assert not (git_repo / "temp.pyproject.toml").exists()
+    assert not (git_repo / "harness" / "temp.pyproject.toml").exists()
 
 
-@pytest.mark.parametrize("present", [(), ("README.template.md",), ("temp.pyproject.toml",)])
-def test_cleanup_requires_both_template_files(present: tuple[str, ...], tmp_path: Path) -> None:
+@pytest.mark.parametrize(
+    ("has_readme", "has_project"),
+    [(False, False), (True, False), (False, True)],
+)
+def test_cleanup_requires_both_template_files(has_readme: bool, has_project: bool, tmp_path: Path) -> None:
     """Cleanup does nothing unless both template inputs identify a template checkout."""
-    for name in present:
-        (tmp_path / name).touch()
+    if has_readme:
+        (tmp_path / "README.template.md").touch()
+    if has_project:
+        (tmp_path / "harness").mkdir()
+        (tmp_path / "harness" / "temp.pyproject.toml").touch()
 
     assert cli.cleanup(tmp_path) is False
 
 
-def test_cleanup_does_not_amend_a_dirty_template(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    """Cleanup only rewrites the historical template commit when the checkout started clean."""
-    (tmp_path / "README.template.md").write_text("readme\n", encoding="utf-8")
-    (tmp_path / "temp.pyproject.toml").write_text("[project]\n", encoding="utf-8")
-    run_git = Mock(side_effect=[" M README.md\n", "867f2df"])
+def test_cleanup_does_not_amend_a_dirty_template(monkeypatch: pytest.MonkeyPatch, git_repo: Path) -> None:
+    """Real dirty state prevents cleanup from amending the historical template commit."""
+    replacement_project = (REPO_ROOT / "harness" / "temp.pyproject.toml").read_text(encoding="utf-8")
+    (git_repo / "pyproject.toml").write_text('[project]\nname = "template"\n', encoding="utf-8")
+    (git_repo / "README.template.md").write_text("replacement project readme\n", encoding="utf-8")
+    (git_repo / "harness").mkdir()
+    (git_repo / "harness" / "temp.pyproject.toml").write_text(replacement_project, encoding="utf-8")
+    gate.run_git(["add", "-A"], git_repo)
+    gate.run_git(["commit", "-q", "-m", "template state"], git_repo)
+    assert not gate.run_git(["status", "--porcelain"], git_repo)
+    original_head = gate.run_git(["rev-parse", "HEAD"], git_repo).strip()
+    (git_repo / "README.md").write_text("uncommitted user work\n", encoding="utf-8")
+    run_git = Mock(wraps=cli.run_git, side_effect=[DEFAULT, "867f2df\n"])
     monkeypatch.setattr(cli, "run_git", run_git)
 
-    assert cli.cleanup(tmp_path) is True
-    assert run_git.call_args_list == [
-        call(["status", "--porcelain"], tmp_path),
-        call(["rev-parse", "--short", "HEAD"], tmp_path),
-    ]
+    assert cli.cleanup(git_repo) is True
+
+    assert gate.run_git(["rev-parse", "HEAD"], git_repo).strip() == original_head
+    assert gate.run_git(["status", "--porcelain"], git_repo)
 
 
 @pytest.mark.parametrize(

pyproject.toml

@@ -154,7 +154,7 @@ security = [
     ".",
 ]
 types = ["pyright", "--outputjson"]
-test = ["pytest", "-p", "no:cacheprovider", "-n", "auto", "--cov", "--cov-report=term-missing", "--cov-fail-under=100", "--hypothesis-show-statistics", "--durations=5"]
+test = ["pytest", "-p", "no:cacheprovider", "-n", "auto", "--cov", "--cov-report=term-missing", "--cov-fail-under=100", "--durations=5"]
 
 [tool.harness.FORBIDDEN]
 DIRS = ["harness/", ".githooks/", ".github/", ".git/", "preferences/", "tests/preferences/", "mutation", "tests/mutation/"]