foundry-habit-hooks-dotnet 1.5.0__tar.gz

foundry_habit_hooks_dotnet-1.5.0/.gitignore

@@ -0,0 +1,6 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc
+.venv/

foundry_habit_hooks_dotnet-1.5.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CMaintz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

foundry_habit_hooks_dotnet-1.5.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: foundry-habit-hooks-dotnet
+Version: 1.5.0
+Summary: The C#/.NET Habit Hooks plugin
+Project-URL: Repository, https://github.com/CMaintz/foundry-habit-hooks-dotnet
+Project-URL: Issues, https://github.com/CMaintz/foundry-habit-hooks-dotnet/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-coding-agents,ci,code-quality,code-smells,csharp,dotnet,linter,refactoring,static-analysis,technical-debt
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Requires-Dist: habit-hooks<1.6,>=1.5
+Description-Content-Type: text/markdown
+
+# foundry-habit-hooks-dotnet
+
+The C#/.NET Habit Hooks plugin: wraps `dotnet build` with
+[SonarAnalyzer.CSharp](https://www.nuget.org/packages/SonarAnalyzer.CSharp)
+active, and maps its structural warnings to habit-hooks smell kinds.
+
+It is the direct analog of the Java plugin's pmd sensor. Where a plain
+`dotnet build -warnaserror` can only fail the build on any warning, this feeds
+the warnings through habit-hooks' snooze index, so an existing backlog is
+grandfathered and only new structural debt gates.
+
+## Install
+
+```sh
+pip install habit-hooks foundry-habit-hooks-dotnet
+```
+
+Installing a plugin does not switch it on. Name it in `plugins`:
+
+```toml
+# .habit-hooks/config.toml
+plugins = ["dotnet", "generic"]
+```
+
+## Requirements
+
+- The .NET SDK (`dotnet` on PATH). `winget install Microsoft.DotNet.SDK.9`
+- The target project references `SonarAnalyzer.CSharp` as an analyzer package.
+
+The plugin ships a default ruleset that enables the structural rules
+(SonarAnalyzer ships them off by default) and passes it with
+`-p:CodeAnalysisRuleSet`. A project that wants its own thresholds or rule set
+overrides it:
+
+```toml
+[sensors.dotnet-build]
+args = ["-p:CodeAnalysisRuleSet=path/to/your.ruleset"]
+```
+
+## Rule mapping
+
+| Sonar rule | Smell |
+| --- | --- |
+| S138 (method length) | oversized-function |
+| S1541 (cyclomatic complexity) | high-complexity |
+| S3776 (cognitive complexity) | high-complexity |
+| S107 (too many parameters) | too-many-parameters |
+| S104 (file length) | oversized-file |
+
+Thresholds are SonarAnalyzer's own defaults. A Sonar rule not in the table is
+not reported.
+
+## Versioning
+
+Released in lockstep with habit-hooks core: the plugin version tracks the
+core's major.minor so the sensor protocol it builds against never drifts. The
+mise `HABIT_HOOKS_VERSION` variable pins both together.

foundry_habit_hooks_dotnet-1.5.0/README.md

@@ -0,0 +1,57 @@
+# foundry-habit-hooks-dotnet
+
+The C#/.NET Habit Hooks plugin: wraps `dotnet build` with
+[SonarAnalyzer.CSharp](https://www.nuget.org/packages/SonarAnalyzer.CSharp)
+active, and maps its structural warnings to habit-hooks smell kinds.
+
+It is the direct analog of the Java plugin's pmd sensor. Where a plain
+`dotnet build -warnaserror` can only fail the build on any warning, this feeds
+the warnings through habit-hooks' snooze index, so an existing backlog is
+grandfathered and only new structural debt gates.
+
+## Install
+
+```sh
+pip install habit-hooks foundry-habit-hooks-dotnet
+```
+
+Installing a plugin does not switch it on. Name it in `plugins`:
+
+```toml
+# .habit-hooks/config.toml
+plugins = ["dotnet", "generic"]
+```
+
+## Requirements
+
+- The .NET SDK (`dotnet` on PATH). `winget install Microsoft.DotNet.SDK.9`
+- The target project references `SonarAnalyzer.CSharp` as an analyzer package.
+
+The plugin ships a default ruleset that enables the structural rules
+(SonarAnalyzer ships them off by default) and passes it with
+`-p:CodeAnalysisRuleSet`. A project that wants its own thresholds or rule set
+overrides it:
+
+```toml
+[sensors.dotnet-build]
+args = ["-p:CodeAnalysisRuleSet=path/to/your.ruleset"]
+```
+
+## Rule mapping
+
+| Sonar rule | Smell |
+| --- | --- |
+| S138 (method length) | oversized-function |
+| S1541 (cyclomatic complexity) | high-complexity |
+| S3776 (cognitive complexity) | high-complexity |
+| S107 (too many parameters) | too-many-parameters |
+| S104 (file length) | oversized-file |
+
+Thresholds are SonarAnalyzer's own defaults. A Sonar rule not in the table is
+not reported.
+
+## Versioning
+
+Released in lockstep with habit-hooks core: the plugin version tracks the
+core's major.minor so the sensor protocol it builds against never drifts. The
+mise `HABIT_HOOKS_VERSION` variable pins both together.

foundry_habit_hooks_dotnet-1.5.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "foundry-habit-hooks-dotnet"
+version = "1.5.0"
+description = "The C#/.NET Habit Hooks plugin"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+  "ai-coding-agents",
+  "ci",
+  "code-quality",
+  "code-smells",
+  "csharp",
+  "dotnet",
+  "linter",
+  "refactoring",
+  "static-analysis",
+  "technical-debt",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Quality Assurance",
+]
+# Released in lockstep with the core: the plugin tracks habit-hooks' major.minor
+# so the sensor protocol it builds against never drifts. Mise's
+# HABIT_HOOKS_VERSION drives both pins together.
+dependencies = ["habit-hooks>=1.5,<1.6"]
+
+[project.urls]
+Repository = "https://github.com/CMaintz/foundry-habit-hooks-dotnet"
+Issues = "https://github.com/CMaintz/foundry-habit-hooks-dotnet/issues"
+
+# The entry point that registers this package under the plugin name `dotnet`,
+# matching how the generic, java and typescript plugins register their own.
+[project.entry-points."habit_hooks.plugins"]
+dotnet = "foundry_habit_hooks_dotnet"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/foundry_habit_hooks_dotnet"]

foundry_habit_hooks_dotnet-1.5.0/src/foundry_habit_hooks_dotnet/__init__.py

@@ -0,0 +1 @@
+"""The dotnet Habit Hooks plugin: package data discovered via the habit_hooks.plugins entry point."""

foundry_habit_hooks_dotnet-1.5.0/src/foundry_habit_hooks_dotnet/config.toml

@@ -0,0 +1,15 @@
+# C#/.NET plugin defaults.
+language = "csharp"
+# A project naming no `files` of its own scans what its plugins declare. `bin/`
+# and `obj/` hold build output and generated sources (`*.g.cs`, AssemblyInfo)
+# the project did not write and cannot change, so they are excluded; the
+# exclusions name `*.cs` because a plugin's exclusions bind the union of every
+# active plugin's globs, not just its own.
+files = ["**/*.cs", "!**/bin/**/*.cs", "!**/obj/**/*.cs"]
+sensors = ["dotnet-build"]
+transformers = []
+
+# The sensor spawns the dotnet SDK directly.
+detectors = [
+  { name = "dotnet", kind = "command", install = "winget install Microsoft.DotNet.SDK.9" },
+]

foundry_habit_hooks_dotnet-1.5.0/src/foundry_habit_hooks_dotnet/sensors/dotnet-build.toml

@@ -0,0 +1 @@
+argv = ["${python}", "${dir}/dotnet_build_sensor.py", "${detector:dotnet}", "${args}", "--", "${files}"]

foundry_habit_hooks_dotnet-1.5.0/src/foundry_habit_hooks_dotnet/sensors/dotnet_build_sensor.py

@@ -0,0 +1,201 @@
+"""Run ``dotnet build`` and print canonical habit-hooks smell findings.
+
+The direct analog of the java plugin's pmd sensor: it wraps an external build,
+reads the structural warnings SonarAnalyzer.CSharp emits, and shapes each one
+into the canonical finding, mapping the Sonar rule id to a smell key.
+
+``dotnet build`` operates on the project or solution in the working directory,
+not on a file list, so (like the generic jscpd sensor) this does not splice
+``${files}`` into the build command. It builds the whole project, then keeps
+only the warnings whose file is in the run's scope, so a ``--file`` or
+``--branch`` run reports scoped findings rather than the whole project's debt.
+
+Warnings are left as warnings (TreatWarningsAsErrors off) so the build still
+completes and this wrapper can read them. That is the whole point: a plain
+``dotnet build -warnaserror`` can only fail the build on any warning, with no
+way to grandfather the backlog and gate only new debt. Feeding the warnings
+through habit-hooks' snooze index is what adds that ratchet.
+
+The sensor is run as a loose script (``${python} ${dir}/dotnet_build_sensor.py``),
+so its own directory is ``sys.path[0]``; the default ruleset it ships lives
+next to it and is found by name, the same in the installed package and a
+vendored copy.
+
+Its argv spells ``${detector:dotnet} ${args} -- ${files}``: ``sys.argv[1]`` is
+the dotnet executable, and ``sys.argv[2:]`` carries any ``[sensors.dotnet-build]
+args`` on one side of a literal ``--`` and the scoped files on the other.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+# Sonar rule id -> habit-hooks smell key (habit_hooks.catalogue). A rule not
+# named here is dropped: the catalogue is the record of what is worth failing a
+# build over, and inventing a smell for every Sonar rule would bury the ones
+# that were chosen.
+RULE_SMELLS = {
+    "S138": "oversized-function",
+    "S1541": "high-complexity",
+    "S3776": "high-complexity",
+    "S107": "too-many-parameters",
+    "S104": "oversized-file",
+}
+
+# One MSBuild warning line:
+#   path\File.cs(12,34): warning S138: message text [path\Project.csproj]
+WARNING = re.compile(
+    r"^(?P<file>.+?)\((?P<line>\d+),\d+\): "
+    r"warning (?P<rule>S\d+): (?P<message>.*?)(?: \[(?P<project>.+?)\])?$"
+)
+
+# dotnet build exits non-zero on a compile error; only 0 is a clean read of its
+# warnings. Anything else is a broken run, not a clean one.
+BUILD_SUCCESS = 0
+
+
+def build_env() -> dict[str, str]:
+    """The environment the build runs in: English, quiet, no telemetry.
+
+    The warning text is parsed, so a localised build would hand back messages
+    this sensor's regex and the mapper never saw.
+    """
+    env = dict(os.environ)
+    env["DOTNET_CLI_UI_LANGUAGE"] = "en"
+    env["DOTNET_NOLOGO"] = "1"
+    env["DOTNET_CLI_TELEMETRY_OPTOUT"] = "1"
+    return env
+
+
+def default_ruleset() -> Path:
+    """The ruleset this plugin ships, which enables the structural rules.
+
+    SonarAnalyzer ships most structural rules off by default, so a bare package
+    reference emits none of them. This is the answer to "the project configured
+    none"; a project naming its own ``-p:CodeAnalysisRuleSet`` in the sensor's
+    args passes it after this one, and MSBuild takes the last.
+    """
+    return Path(__file__).with_name("sonar.ruleset")
+
+
+def build_command(dotnet: str, extra_args: list[str]) -> list[str]:
+    """The ``dotnet build`` invocation, with this plugin's ruleset as the default."""
+    return [
+        dotnet,
+        "build",
+        "--no-incremental",
+        "-nologo",
+        "-p:TreatWarningsAsErrors=false",
+        f"-p:CodeAnalysisRuleSet={default_ruleset()}",
+        *extra_args,
+    ]
+
+
+def run_build(dotnet: str, extra_args: list[str]) -> subprocess.CompletedProcess[str]:
+    """What the build said, run in the working directory."""
+    return subprocess.run(
+        build_command(dotnet, extra_args),
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",  # one invalid byte must not take the sensor down
+    )
+
+
+def split_argv(argv: list[str]) -> tuple[list[str], list[str]]:
+    """``argv`` split on the last literal ``--``: build args before, files after."""
+    if "--" not in argv:
+        return argv, []
+    index = len(argv) - 1 - argv[::-1].index("--")
+    return argv[:index], argv[index + 1 :]
+
+
+def parse_warnings(output: str) -> list[dict]:
+    """Every structural warning the build printed, as ``{file, line, rule, message}``.
+
+    Deduplicated on ``(file, line, rule)``: a multi-target or multi-project
+    build compiles each source once per target and repeats every warning.
+    """
+    seen: set[tuple[str, str, str]] = set()
+    warnings = []
+    for line in output.splitlines():
+        warning = _parsed_warning(line.strip())
+        if warning is None:
+            continue
+        identity = (warning["file"], warning["line"], warning["rule"])
+        if identity not in seen:
+            seen.add(identity)
+            warnings.append(warning)
+    return warnings
+
+
+def _parsed_warning(line: str) -> dict | None:
+    match = WARNING.match(line)
+    if match is None or match["rule"] not in RULE_SMELLS:
+        return None
+    return match.groupdict()
+
+
+def in_scope(warnings: list[dict], files: list[str]) -> list[dict]:
+    """The warnings whose file is one the run scoped this sensor to.
+
+    MSBuild reports absolute paths and the scope arrives project-relative, so
+    both sides are compared as absolute, case-folded paths. An empty scope keeps
+    nothing: the run narrowed this sensor away and the build's own warnings are
+    not the scope's answer.
+    """
+    scoped = {_normalised(path) for path in files}
+    return [w for w in warnings if _normalised(w["file"]) in scoped]
+
+
+def _normalised(path: str) -> str:
+    return os.path.normcase(os.path.abspath(path))
+
+
+def issue(warning: dict) -> dict:
+    """One warning as a canonical issue, keyed by its file like the pmd sensor."""
+    return {
+        "key": warning["file"],
+        "details": {
+            "file": warning["file"],
+            "line": int(warning["line"]),
+            "message": warning["message"],
+            "source": "sonar:" + warning["rule"],
+        },
+    }
+
+
+def findings(warnings: list[dict]) -> list[dict]:
+    """The warnings grouped into one finding per smell."""
+    by_smell: dict[str, list[dict]] = {}
+    for warning in warnings:
+        by_smell.setdefault(RULE_SMELLS[warning["rule"]], []).append(issue(warning))
+    return [
+        {"smell": smell, "details": {}, "issues": issues}
+        for smell, issues in by_smell.items()
+    ]
+
+
+def main() -> int:
+    dotnet, argv = sys.argv[1], sys.argv[2:]
+    extra_args, files = split_argv(argv)
+    result = subprocess.CompletedProcess([], BUILD_SUCCESS, "", "")
+    try:
+        result = run_build(dotnet, extra_args)
+    except OSError as error:
+        sys.stderr.write(f"dotnet build could not start: {error}\n")
+        return 2
+    if result.returncode != BUILD_SUCCESS:
+        sys.stderr.write(result.stdout[-4000:] or result.stderr[-4000:])
+        return 2
+    scoped = in_scope(parse_warnings(result.stdout), files)
+    print(json.dumps(findings(scoped)))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

foundry_habit_hooks_dotnet-1.5.0/src/foundry_habit_hooks_dotnet/sensors/sonar.ruleset

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Habit-hooks structural smell rules for C#. Reached for only when the project
+  names no CodeAnalysisRuleSet of its own; a project's own ruleset or
+  .editorconfig severity wins. SonarAnalyzer.CSharp ships these rules off by
+  default, so enabling them here is what makes the sensor emit anything.
+-->
+<RuleSet Name="habit-hooks dotnet structural smells" ToolsVersion="15.0">
+  <Rules AnalyzerId="SonarAnalyzer.CSharp" RuleNamespace="SonarAnalyzer.CSharp">
+    <Rule Id="S104" Action="Warning" />
+    <Rule Id="S107" Action="Warning" />
+    <Rule Id="S138" Action="Warning" />
+    <Rule Id="S1541" Action="Warning" />
+    <Rule Id="S3776" Action="Warning" />
+  </Rules>
+</RuleSet>