DEVX-5: feat: add DEFAULT_INFRASTRUCTURE and configurable task prefix

2026-06-22 19:03:53 +00:00
parent 33b09c162d
commit 6436c5dd38
6 changed files with 339 additions and 96 deletions
@@ -6,8 +6,11 @@ Runs as the final job in ci.yml. Reads the task ID from ``.taskid`` file
 validates the PR title, and squash-merges with a conventional commit
 message prefixed by the task ID.

-PR title format:    ``DEVX-N: <vikunja task title>``
-Merge commit format: ``DEVX-N: <conventional commit message>``
+PR title format:    ``{PREFIX}-N: <vikunja task title>``
+Merge commit format: ``{PREFIX}-N <conventional commit message>``
+
+The ``{PREFIX}`` is determined by ``DEVX_TASK_PREFIX`` (default: ``DEVX``).
+Each project sets its own prefix (e.g., ``GRM``, ``INFRA``).

 The conventional commit message is extracted from the PR commits.
 This allows the PR title to be a human-friendly Vikunja task title
@@ -32,6 +35,7 @@ from devx.config import (
    DEFAULT_PER_PAGE,
    GITEA_API_URL,
    TASK_ID_RE,
+    TASK_PREFIX,
    VIKUNJA_API_URL,
    VIKUNJA_PROJECT_ID,
 )
@@ -39,7 +43,7 @@ from devx.exceptions import APIError
 from devx.i18n import _

 TASKID_FILE = ".taskid"
-PR_TITLE_RE = re.compile(r"^DEVX-\d+:\s+.+")
+PR_TITLE_RE = re.compile(rf"^{TASK_PREFIX}-\d+:\s+.+")

 load_dotenv()

@@ -84,14 +88,15 @@ def extract_task_id(branch: str) -> str:
 def validate_pr_title(pr_title: str, task_id: str) -> None:
    """Raise ClickException if PR title does not follow the required format.

-    Expected: ``DEVX-N: <vikunja task title>``
+    Expected: ``{PREFIX}-N: <vikunja task title>``
    """
    if not PR_TITLE_RE.match(pr_title):
        raise click.ClickException(
            _(
-                "Oops! PR title must follow format 'DEVX-N: <task title>'.\n"
+                "Oops! PR title must follow format '{prefix}-N: <task title>'.\n"
                "  Expected: {task_id}: <task title>\n"
                "  Got:      {pr_title}",
+                prefix=TASK_PREFIX,
                task_id=task_id,
                pr_title=pr_title,
            )
@@ -15,6 +15,12 @@ affect the published package (user-facing) or only the CI/CD infrastructure
 user-facing.  This prevents new file types from accidentally skipping
 releases — a critical safety property.  When in doubt, release.

+**Framework-provided defaults**: The framework ships with
+``DEFAULT_INFRASTRUCTURE`` — a curated list of paths that are
+infrastructure for ANY Python project (CI workflows, tests, docs,
+lint config, etc.).  Projects inherit these automatically and only
+need to specify what's *different* about their project.
+
 **Config-driven**: Classification rules are read from ``[tool.devx.classify]``
 in ``pyproject.toml``.  No project needs to modify the framework code.
 Each project declares its own paths; the framework handles the logic.
@@ -31,8 +37,9 @@ Each project declares its own paths; the framework handles the logic.
     ``__version__`` — a release artifact, not user-facing code).

  3. **Infrastructure patterns** (deny-list)
-     Path globs matching infrastructure files.  Changes to these don't
-     trigger a release.  Examples: ``.gitea/**``, ``tests/**``, ``docs/**``.
+     Path globs matching infrastructure files.  This is the union of
+     ``DEFAULT_INFRASTRUCTURE`` and the project's ``infrastructure`` list.
+     Changes to these don't trigger a release.

  4. **Default**: user-facing (lowest priority — safe default)

@@ -41,27 +48,28 @@ Each project declares its own paths; the framework handles the logic.
  conditional execution.  A file can be both infrastructure (no release)
  and tagged ``ansible`` (run molecule tests).  Tags are evaluated
  independently of the user-facing/infrastructure classification.
+  The ``--check`` CLI option accepts any tag name defined in the config,
+  and ``--github-output`` writes ``<tag>-changed`` for each configured tag.

 == Configuration ==

 In ``pyproject.toml``::

    [tool.devx.classify]
-    # Infrastructure paths — changes here don't trigger a release
+    # Whether to merge with DEFAULT_INFRASTRUCTURE (default: true).
+    # Set to false to specify all patterns explicitly.
+    # use_defaults = true
+
+    # Project-specific infrastructure paths (merged with defaults).
+    # Only list paths NOT already in DEFAULT_INFRASTRUCTURE.
    infrastructure = [
-        ".gitea/**",
-        "tests/**",
-        "docs/**",
-        "Makefile",
-        "AGENTS.md",
-        "README.md",
-        "CHANGELOG.md",
+        "scripts/**",       # e.g., if scripts/ is dev-only tooling
    ]

    # Infrastructure overrides — files that would default to user-facing
    # but are actually infrastructure
    infrastructure_overrides = [
-        "src/devx/__init__.py",
+        "src/mypkg/__init__.py",   # only contains __version__
    ]

    # User-facing overrides — safety override for broad infrastructure patterns
@@ -72,13 +80,36 @@ In ``pyproject.toml``::
    [tool.devx.classify.tags]
    ansible = ["ansible/**", ".ansible-lint"]

+== What counts as "user-facing" ==
+
+A change is user-facing if it affects the behavior of the installed
+package.  For a library/CLI tool, this means:
+
+  - Source code in ``src/`` (except ``__init__.py`` which only holds
+    ``__version__``)
+  - Package metadata (``pyproject.toml`` — dependencies, entry points)
+  - Ansible roles, playbooks, templates (if the project ships Ansible)
+  - Translation files (user-visible messages)
+  - Any file not explicitly classified as infrastructure
+
+A change is infrastructure if it only affects the project's own
+development/CI environment:
+
+  - CI/CD workflows (``.gitea/**``, ``.github/**``)
+  - Tests (``tests/**``)
+  - Documentation (``docs/**``, ``README.md``, ``CHANGELOG.md``)
+  - Linting/formatting config (``.ruff.toml``, ``.pre-commit-config.yaml``)
+  - Build tooling (``Makefile``, ``cliff.toml``)
+  - Git hooks (``hooks/**``)
+  - Generated scripts (``activate.sh``, ``activate.fish``, ``activate.zsh``)
+
 == Glob Syntax ==

 Patterns support standard glob syntax:

  - ``**`` matches any number of path segments (including zero)
  - ``*`` matches any characters within a single path segment
-  - ``?`` matches a single character within a path segment
+  - ``?`` matches a single character within a single path segment
  - Everything else is matched literally

 Examples:
@@ -90,6 +121,8 @@ Examples:
 Usage:
  python3 -m devx.ci.classify_changes [--base <ref>] [--head <ref>]
  python3 -m devx.ci.classify_changes --base v0.3.0 --head HEAD
+  python3 -m devx.ci.classify_changes --check ansible --quiet
+  python3 -m devx.ci.classify_changes --github-output
 """

 from __future__ import annotations
@@ -167,9 +200,9 @@ def _glob_to_regex(pattern: str) -> re.Pattern[str]:
    """Convert a glob pattern to a compiled regex.

    Supports:
-      - ``**``  → matches any number of path segments (including zero)
-      - ``*``   → matches any chars within a single path segment
-      - ``?``   → matches a single char within a path segment
+      - ``**``  -> matches any number of path segments (including zero)
+      - ``*``   -> matches any chars within a single path segment
+      - ``?``   -> matches a single char within a path segment
      - All other characters are matched literally
    """
    # Handle ** at the end (e.g., ".gitea/**")
@@ -214,45 +247,114 @@ def _matches_glob(file_path: str, pattern: str) -> bool:
 # ---------------------------------------------------------------------------


+# ---------------------------------------------------------------------------
+# Default infrastructure patterns
+# ---------------------------------------------------------------------------
+
+# Common infrastructure paths that apply to ANY Python project using devx.
+# Projects inherit these automatically and only need to specify project-specific
+# paths in their [tool.devx.classify] section.
+#
+# Rationale: these files/directories are development tooling, CI/CD config,
+# or generated artifacts. Changes to them don't affect the installed package's
+# behavior, so they don't warrant a release.
+DEFAULT_INFRASTRUCTURE: list[str] = [
+    # CI/CD workflow definitions
+    ".gitea/**",
+    ".github/**",
+    # Test files
+    "tests/**",
+    # Documentation
+    "docs/**",
+    # Git hooks
+    "hooks/**",
+    # Build tooling
+    "Makefile",
+    "cliff.toml",
+    # Linting / formatting config
+    ".pre-commit-config.yaml",
+    ".ruff.toml",
+    ".ansible-lint",
+    # Environment templates (not the actual .env which is gitignored)
+    ".env.example",
+    # Git config
+    ".gitignore",
+    # Project-level documentation (not part of the installed package)
+    "AGENTS.md",
+    "README.md",
+    "CHANGELOG.md",
+    "TROUBLESHOOTING.md",
+    # Generated venv activation scripts (created by `make setup`)
+    "activate.sh",
+    "activate.fish",
+    "activate.zsh",
+    # CI task tracking file (written by CI, not by developers)
+    ".taskid",
+]
+
+
@dataclass
 class ClassifierConfig:
    """Configuration for the change classifier.

    Loaded from ``[tool.devx.classify]`` in ``pyproject.toml``.

+    By default, the framework's ``DEFAULT_INFRASTRUCTURE`` patterns are
+    merged with the project's ``infrastructure`` list.  Set
+    ``use_defaults = false`` to disable defaults and specify all
+    patterns explicitly.
+
    Attributes:
-        infrastructure: Glob patterns for infrastructure paths.
+        infrastructure: Glob patterns for infrastructure paths
+            (merged with DEFAULT_INFRASTRUCTURE unless use_defaults is False).
        infrastructure_overrides: Exact paths that are infrastructure
            despite not matching any infrastructure pattern.
        user_facing_overrides: Exact paths that are user-facing
            despite matching an infrastructure pattern (safety override).
        tags: Dict mapping tag name to list of glob patterns.
+        use_defaults: If True (default), merge with DEFAULT_INFRASTRUCTURE.
    """

    infrastructure: list[str] = field(default_factory=list)
    infrastructure_overrides: list[str] = field(default_factory=list)
    user_facing_overrides: list[str] = field(default_factory=list)
    tags: dict[str, list[str]] = field(default_factory=dict)
+    use_defaults: bool = True

    @classmethod
    def from_pyproject(cls, pyproject_path: str = "pyproject.toml") -> ClassifierConfig:
        """Load classifier config from pyproject.toml.

        Reads the ``[tool.devx.classify]`` section.  If the section or
-        file is missing, returns a config with empty lists (everything
-        defaults to user-facing — safe-by-default).
+        file is missing, returns a config with only DEFAULT_INFRASTRUCTURE
+        (everything else defaults to user-facing — safe-by-default).
        """
        path = Path(pyproject_path)
        if not path.exists():
-            return cls()
+            return cls(infrastructure=list(DEFAULT_INFRASTRUCTURE))
        with open(path, "rb") as f:  # noqa: PTH123
            data: dict[str, Any] = tomllib.load(f)
        classify_cfg = data.get("tool", {}).get("devx", {}).get("classify", {})
+
+        use_defaults = classify_cfg.get("use_defaults", True)
+        project_infra = list(classify_cfg.get("infrastructure", []))
+
+        if use_defaults:
+            # Merge defaults with project-specific patterns (deduplicated)
+            merged = list(DEFAULT_INFRASTRUCTURE)
+            for p in project_infra:
+                if p not in merged:
+                    merged.append(p)
+            infrastructure = merged
+        else:
+            infrastructure = project_infra
+
        return cls(
-            infrastructure=list(classify_cfg.get("infrastructure", [])),
+            infrastructure=infrastructure,
            infrastructure_overrides=list(classify_cfg.get("infrastructure_overrides", [])),
            user_facing_overrides=list(classify_cfg.get("user_facing_overrides", [])),
            tags={k: list(v) for k, v in classify_cfg.get("tags", {}).items()},
+            use_defaults=use_defaults,
        )


@@ -506,27 +608,30 @@ def _write_github_output(key: str, value: str) -> None:
@click.option("--quiet", is_flag=True, default=False, help="Only output true/false.")
@click.option(
    "--check",
-    type=click.Choice(["all", "ansible", "user-facing"]),
    default="all",
-    help="Check specific category: all (default), ansible, or user-facing.",
+    help="Check specific category: 'all' (default), 'user-facing', or any tag name "
+    "defined in [tool.devx.classify.tags] (e.g., 'ansible').",
 )
@click.option(
    "--github-output",
    "github_output",
    is_flag=True,
    default=False,
-    help="Write results to $GITHUB_OUTPUT file (for CI workflow steps).",
+    help="Write results to $GITHUB_OUTPUT file (for CI workflow steps). "
+    "Outputs 'user-facing-changed' and '<tag>-changed' for each configured tag.",
 )
 def main(base: str | None, head: str, quiet: bool, check: str, github_output: bool) -> None:
    """Classify git changes and output results."""
    classifier = _get_classifier()
+    available_tags = list(classifier.config.tags.keys())

    if base is None:
        base = get_latest_tag()
        if not base:
            if github_output:
-                _write_github_output("ansible-changed", "true")
                _write_github_output("user-facing-changed", "true")
+                for tag in available_tags:
+                    _write_github_output(f"{tag}-changed", "true")
                click.echo("No tags found — treating all changes as user-facing.")
                return
            if quiet:
@@ -538,8 +643,9 @@ def main(base: str | None, head: str, quiet: bool, check: str, github_output: bo
    files = get_changed_files(base, head)
    if not files:
        if github_output:
-            _write_github_output("ansible-changed", "false")
            _write_github_output("user-facing-changed", "false")
+            for tag in available_tags:
+                _write_github_output(f"{tag}-changed", "false")
            click.echo(f"No changes between {base} and {head}.")
            return
        if quiet:
@@ -551,35 +657,40 @@ def main(base: str | None, head: str, quiet: bool, check: str, github_output: bo
    result = classifier.classify(files)

    if github_output:
-        _write_github_output("ansible-changed", "true" if result.has_tag("ansible") else "false")
        _write_github_output("user-facing-changed", "true" if result.has_user_facing else "false")
-        click.echo(f"Ansible files changed: {result.has_tag('ansible')}")
+        for tag in available_tags:
+            _write_github_output(f"{tag}-changed", "true" if result.has_tag(tag) else "false")
        click.echo(f"User-facing files changed: {result.has_user_facing}")
+        for tag in available_tags:
+            click.echo(f"{tag.capitalize()} files changed: {result.has_tag(tag)}")
        return

-    if check == "ansible":
-        ansible_files = result.tags.get("ansible", [])
-        has_ansible = bool(ansible_files)
+    # --check: check a specific tag or user-facing
+    if check != "all":
+        if check == "user-facing":
+            checked_files = result.user_facing
+            has_checked = bool(checked_files)
+            label = "User-facing"
+        elif check in available_tags:
+            checked_files = result.tags.get(check, [])
+            has_checked = bool(checked_files)
+            label = check.capitalize()
+        else:
+            raise click.ClickException(
+                _(
+                    "Unknown check category '{check}'. Available: all, user-facing{tags}",
+                    check=check,
+                    tags=", " + ", ".join(available_tags) if available_tags else "",
+                )
+            )
        if quiet:
-            click.echo("true" if has_ansible else "false")
+            click.echo("true" if has_checked else "false")
            return
-        click.echo(_("\nAnsible files changed ({count}):", count=len(ansible_files)))
-        for f in ansible_files:
-            click.echo(f"  {f}")
-        click.echo(_("\nResult: {status}", status="Ansible changes detected" if has_ansible else "No Ansible changes"))
-        return
-
-    if check == "user-facing":
-        user_files = result.user_facing
-        has_user = bool(user_files)
-        if quiet:
-            click.echo("true" if has_user else "false")
-            return
-        click.echo(_("\nUser-facing files changed ({count}):", count=len(user_files)))
-        for f in user_files:
+        click.echo(_("\n{label} files changed ({count}):", label=label, count=len(checked_files)))
+        for f in checked_files:
            click.echo(f"  {f}")
        click.echo(
-            _("\nResult: {status}", status="User-facing changes detected" if has_user else "No user-facing changes")
+            _("\nResult: {status}", status=f"{label} changes detected" if has_checked else f"No {label} changes")
        )
        return

@@ -596,6 +707,12 @@ def main(base: str | None, head: str, quiet: bool, check: str, github_output: bo
    click.echo(_("\nWorkflow-only changes ({count}):", count=len(result.infrastructure)))
    for f in result.infrastructure:
        click.echo(f"  {f}")
+    for tag in available_tags:
+        tag_files = result.tags.get(tag, [])
+        if tag_files:
+            click.echo(_("\n{tag} files ({count}):", tag=tag.capitalize(), count=len(tag_files)))
+            for f in tag_files:
+                click.echo(f"  {f}")
    if has_user:
        status = "USER-FACING changes detected — release needed"
    else:
@@ -639,5 +639,17 @@
    "de": "unbekannt",
    "ru": "неизвестно",
    "zh": "未知"
+  },
+  "\n{label} files changed ({count}):": {
+    "en": "\n{label} files changed ({count}):"
+  },
+  "\n{tag} files ({count}):": {
+    "en": "\n{tag} files ({count}):"
+  },
+  "Oops! PR title must follow format '{prefix}-N: <task title>'.\n  Expected: {task_id}: <task title>\n  Got:      {pr_title}": {
+    "en": "Oops! PR title must follow format '{prefix}-N: <task title>'.\n  Expected: {task_id}: <task title>\n  Got:      {pr_title}"
+  },
+  "Unknown check category '{check}'. Available: all, user-facing{tags}": {
+    "en": "Unknown check category '{check}'. Available: all, user-facing{tags}"
  }
 }