A bare repomatic init now re-syncs a tool config

Author: kdeldycke

changelog.md

@@ -8,6 +8,7 @@
 - `lint-repo` now fails when a workflow asks `repomatic metadata` for a key that no longer exists. `init` syncs a header-only workflow's header and pins but never its job bodies, so a retired key sits in a `run:` line nothing sweeps until the command rejects it and every job gated on it through `needs:` dies with it. `coverage_cells` took a downstream test workflow down this way.
 - `lint-repo` now warns when a Sphinx project's GitHub website field differs from the documentation URL declared in `[project.urls]`.
 - `runner-images` now watches every image the workflows name literally, not just the curated test axes. An off-axis runner is the one nothing tracks, so its retirement was the one announcement never flagged.
+- A bare `repomatic init` now re-syncs a tool config the repository already carries, so `[tool.typos]`, `[tool.uv]` and `[tool.bumpversion]` follow the bundled template once adopted. Naming them explicitly governs adoption, not upkeep, and the only sync that runs unattended is the bare `init` behind the `sync-repomatic` job: a section written by hand therefore never picked up a single canonical rule. An `awesome-*` list had been spell-checked without the proper-noun map since it migrated.
 - New `ci-status` command reporting each workflow's latest run and which of its failing jobs actually gate a merge. Reads jobs rather than runs, so an allowed-failure probe cannot hide inside a green run conclusion.
 - New `repomatic run <tool> --verify` reporting which files a formatter would rewrite, without touching the working tree.
 - `repomatic run` now resolves a tool's targets itself when given no arguments, running the invocation CI performs. A tool with no matching file is skipped instead of invoked pathless.

docs/configuration.md

@@ -184,6 +184,18 @@ Scope is a default, not a rule. Naming a component on the command line, or listi
 $ repomatic init changelog
 ```
 
+### Adopting a tool config
+
+Tool configs are the one group a bare `repomatic init` never introduces. `[tool.typos]`, `[tool.ruff]`, `[tool.pytest]` and their siblings land only when named:
+
+```shell-session
+$ repomatic init typos
+```
+
+Adoption is one-way. Once the section exists, a bare `init` picks it back up on every run, so the `sync-repomatic` job keeps it aligned with the bundled template from then on: new canonical rules arrive, local additions survive. The section is a managed file like any other after that, which makes it subject to [§ Diverging from a managed file](#diverging-from-a-managed-file): the sync rebuilds it from the template and grafts local content back, so hand-written comments inside it do not survive.
+
+Only the configs repomatic keeps syncing behave this way, `typos`, `uv` and `bumpversion`. The rest (`ruff`, `pytest`, `coverage`, `mypy`, `mdformat`) are starting points the repository owns outright after the first write, and `init` never revisits them.
+
 ## `[tool.X]` bridge and tool runner
 
 `repomatic run` also bridges the gap for tools that can't read `pyproject.toml` natively: write your config in `[tool.<name>]` and repomatic translates it to the tool's native format at invocation time. See the [tool runner](tool-runner.md) page for the full list of supported tools, config resolution precedence, binary caching, and a tutorial.

repomatic/init_project.py

@@ -63,7 +63,12 @@
 from .metadata import Metadata, all_metadata_keys
 from .plugin import merge_plugin_settings
 from .prepare_release import SELF_PIN_COOLDOWN_EXEMPTION
-from .pyproject import is_python_package, is_python_project, resolve_source_paths
+from .pyproject import (
+    is_python_package,
+    is_python_project,
+    read_pyproject_toml,
+    resolve_source_paths,
+)
 from .registry import (
     COMPONENTS,
     COMPONENTS_BY_NAME,
@@ -834,6 +839,42 @@ def prune_paths(
             target.unlink()
 
 
+def adopted_ongoing_configs(output_dir: Path) -> set[str]:
+    """Return the ongoing tool configs whose section `pyproject.toml` already carries.
+
+    {attr}`~repomatic.registry.InitDefault.EXPLICIT` governs *adoption*, not
+    upkeep: it keeps a bare `init` from pushing `[tool.typos]` onto a repository
+    that never asked for one. Once the section is there the repository has
+    asked, so an {attr}`~repomatic.registry.SyncMode.ONGOING` component rejoins
+    the bare-init set and resumes tracking the bundled template.
+
+    Without this the two flags cancel out. The only sync that ever runs
+    unattended is the bare `init` the `sync-repomatic` job calls, so an ONGOING
+    section is otherwise re-derived only when a human types its component name,
+    and a `[tool.typos]` written by hand sits indefinitely beside a bundled
+    template it never adopts a single rule from.
+
+    {attr}`~repomatic.registry.SyncMode.BOOTSTRAP` components stay out: their
+    template is a starting point the repository owns outright after the first
+    write, and re-selecting one would revert deliberate local edits.
+
+    :param output_dir: Repository root holding `pyproject.toml`.
+    :return: Component names to add to a bare `init` selection. Empty when the
+        file is absent, unparseable, or carries no `[tool]` table.
+    """
+    tool_table = read_pyproject_toml(output_dir).get("tool", {})
+    if not tool_table:
+        return set()
+    return {
+        comp.name
+        for comp in COMPONENTS
+        if isinstance(comp, ToolConfigComponent)
+        and comp.init_default is InitDefault.EXPLICIT
+        and comp.sync_mode is SyncMode.ONGOING
+        and comp.tool_name in tool_table
+    }
+
+
 def run_init(
     output_dir: Path,
     components: Sequence[str] = (),
@@ -899,6 +940,7 @@ def run_init(
             for c in COMPONENTS
             if c.init_default in (InitDefault.INCLUDE, InitDefault.EXCLUDE)
         }
+        selected |= adopted_ongoing_configs(output_dir)
     result = InitResult()
 
     # Auto-include awesome-template for awesome-* repositories.

tests/test_init_project.py

@@ -40,6 +40,7 @@
     _highest_upstream_pin,
     _select_cooldown_pin,
     _update_tool_config,
+    adopted_ongoing_configs,
     default_version_pin,
     export_content,
     get_data_content,
@@ -515,6 +516,62 @@ def test_init_config_lychee_preserves_other_sections(toml_file) -> None:
     assert "lychee" in parsed["tool"]
 
 
+@pytest.mark.parametrize(
+    ("content", "expected"),
+    (
+        pytest.param("", set(), id="no-tool-table"),
+        pytest.param('[project]\nname = "papaya"\n', set(), id="project-only"),
+        pytest.param("[tool.typos]\n", {"typos"}, id="ongoing-adopted"),
+        pytest.param("[tool.ruff]\n", set(), id="bootstrap-stays-out"),
+        pytest.param("[tool.gitleaks]\n", set(), id="unmanaged-section"),
+        pytest.param(
+            "[tool.typos]\n[tool.uv]\n[tool.bumpversion]\n[tool.mypy]\n",
+            {"typos", "uv", "bumpversion"},
+            id="every-ongoing-config",
+        ),
+    ),
+)
+def test_adopted_ongoing_configs(
+    tmp_path: Path, content: str, expected: set[str]
+) -> None:
+    """A section already on disk re-enters the bare-init set, if it is ONGOING.
+
+    `EXPLICIT` keeps `init` from pushing a tool config onto a repository that
+    never asked for one; it must not also stop the ongoing sync of a section the
+    repository already carries. `BOOTSTRAP` templates stay out either way: the
+    repository owns them outright after the first write.
+    """
+    (tmp_path / "pyproject.toml").write_text(content, encoding="UTF-8")
+    assert adopted_ongoing_configs(tmp_path) == expected
+
+
+def test_adopted_ongoing_configs_without_pyproject(tmp_path: Path) -> None:
+    """A repository with no pyproject.toml adopts nothing."""
+    assert adopted_ongoing_configs(tmp_path) == set()
+
+
+def test_adopted_ongoing_configs_are_explicit_and_ongoing(tmp_path: Path) -> None:
+    """Whatever the helper returns is an EXPLICIT, ONGOING tool config.
+
+    Guards the invariant against a registry edit that flips a component's
+    `init_default` or `sync_mode` without revisiting this selection path.
+    """
+    sections = "\n".join(
+        f"[{comp.tool_section}]"
+        for comp in COMPONENTS
+        if isinstance(comp, ToolConfigComponent)
+    )
+    (tmp_path / "pyproject.toml").write_text(sections + "\n", encoding="UTF-8")
+
+    adopted = adopted_ongoing_configs(tmp_path)
+    assert adopted
+    for name in adopted:
+        comp = COMPONENTS_BY_NAME[name]
+        assert isinstance(comp, ToolConfigComponent)
+        assert comp.init_default is InitDefault.EXPLICIT
+        assert comp.sync_mode is SyncMode.ONGOING
+
+
 def test_uv_component_uses_overlay_ongoing() -> None:
     """The uv tool config is an ongoing overlay, not a full-section rebuild."""
     comp = COMPONENTS_BY_NAME["uv"]