wssweep 0.1.0__tar.gz

wssweep-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wssweep contributors
+
+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.

wssweep-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: wssweep
+Version: 0.1.0
+Summary: Zero-config whitespace doctor: find (and --fix) trailing whitespace, mixed line endings, missing/extra final newlines, BOMs and mixed indentation. Zero dependencies.
+Author: yyfjj
+License: MIT
+Project-URL: Homepage, https://github.com/jjdoor/wssweep-py
+Project-URL: Repository, https://github.com/jjdoor/wssweep-py
+Project-URL: Issues, https://github.com/jjdoor/wssweep-py/issues
+Keywords: whitespace,trailing-whitespace,line-endings,crlf,eol,lint,formatter,cli,ci
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# wssweep
+
+**A zero-config whitespace doctor.** Run it on any repo and it instantly finds —
+and with `--fix`, cleans — the whitespace problems that pollute diffs and break
+across platforms: trailing whitespace, mixed CRLF/LF line endings, a missing
+final newline, extra trailing blank lines, a UTF-8 BOM, lone CRs, and tabs mixed
+with spaces in indentation.
+
+```bash
+pipx run wssweep
+#   config.yml  (1)
+#        -  mixed-eol  mixed line endings (CRLF×3, LF×1)
+#
+#   src/app.js  (2)
+#        -  missing-final-newline  no newline at end of file
+#       14: trailing-whitespace  trailing whitespace
+#
+#   ✖ 3 whitespace issues in 2 files  (missing-final-newline=1, mixed-eol=1, trailing-whitespace=1)
+
+pipx run wssweep --fix   # clean them in place
+```
+
+No config file, no framework. Exits non-zero when it finds issues, so it drops
+straight into CI. Pure standard library. Also on npm (`npx wssweep`) — the two
+builds produce **byte-for-byte identical** output *and* identical fixes.
+
+## Why another whitespace tool?
+
+Because today this takes three or four tools wired together:
+
+- **editorconfig-checker** reports, but needs you to author an `.editorconfig`
+  first, and it can't fix anything.
+- **pre-commit**'s `trailing-whitespace` / `end-of-file-fixer` /
+  `mixed-line-ending` hooks *do* fix — but only inside the pre-commit framework,
+  and they're three separate hooks. Nobody runs them ad-hoc on a fresh checkout.
+- **prettier** fixes whitespace only as a side effect of reformatting all your
+  code, is language-aware, and won't touch files it can't parse.
+- **dos2unix** only does line endings.
+
+`wssweep` is the one command — `pip`/`npx`, zero config — that reports *all*
+seven whitespace smells at once with line numbers and optionally fixes them in
+place, with a clean CI exit code, identical on Python and Node.
+
+## What it checks
+
+| check | what | `--fix` |
+|---|---|---|
+| `trailing-whitespace` | space/tab at end of a line | trims it |
+| `mixed-eol` | a file containing **both** CRLF and LF | normalizes to LF |
+| `lone-cr` | a bare CR (old-Mac line ending) | normalizes |
+| `missing-final-newline` | non-empty file not ending in a newline | appends one |
+| `trailing-blank-lines` | extra blank line(s) at end of file | collapses to one |
+| `utf8-bom` | a leading UTF-8 BOM | strips it |
+| `mixed-indentation` | tabs **and** spaces in one indent | report-only (needs your tab width) |
+
+Opinionated, zero-config defaults: a consistently-CRLF file is **fine** (only
+*mixed* endings are flagged), `.bat`/`.cmd` keep CRLF when fixed, and Markdown's
+two-trailing-spaces hard line break is preserved (trailing-whitespace is skipped
+in `.md`).
+
+## Usage
+
+```bash
+wssweep                       # scan the current directory
+wssweep src/ docs/            # scan specific paths
+wssweep --fix                 # fix in place (atomic; only files that change)
+wssweep --crlf --fix          # normalize endings to CRLF instead of LF
+wssweep --skip=mixed-indentation   # turn off a check
+wssweep --exclude='*.min.js'  # skip paths by glob (repeatable)
+wssweep --json                # machine output (byte-identical both builds)
+```
+
+`.git`, `node_modules`, `dist`, `build`, `vendor`, `.venv` and friends are
+skipped by default, as are binary files (detected by extension + a NUL-byte /
+non-UTF-8 content check) and files over 5 MB. `--all` overrides those skips.
+
+Exit codes: `0` clean · `1` issues found · `2` error. (`--fix` exits `0` once
+everything fixable is fixed; a leftover `mixed-indentation` keeps it `1`.)
+
+## How it works
+
+It reads every file as **raw bytes** and scans a byte-faithful (latin-1) view, so
+it never mangles encodings and the Python and Node builds agree to the byte: line
+endings are classified from the bytes (never `splitlines`, which over-splits),
+"whitespace" means exactly space and tab (never `\s`, which differs across
+languages), and `--fix` writes raw bytes atomically (temp file + rename),
+touching only files that actually change and preserving file modes. Fixing is
+idempotent — run it twice, the second run does nothing.
+
+## Install
+
+```bash
+pip install wssweep  # or pipx run wssweep
+npm i -g wssweep     # Node build, identical behaviour
+```
+
+Python ≥ 3.8 or Node ≥ 18. No dependencies.
+
+## License
+
+MIT

wssweep-0.1.0/README.md

@@ -0,0 +1,101 @@
+# wssweep
+
+**A zero-config whitespace doctor.** Run it on any repo and it instantly finds —
+and with `--fix`, cleans — the whitespace problems that pollute diffs and break
+across platforms: trailing whitespace, mixed CRLF/LF line endings, a missing
+final newline, extra trailing blank lines, a UTF-8 BOM, lone CRs, and tabs mixed
+with spaces in indentation.
+
+```bash
+pipx run wssweep
+#   config.yml  (1)
+#        -  mixed-eol  mixed line endings (CRLF×3, LF×1)
+#
+#   src/app.js  (2)
+#        -  missing-final-newline  no newline at end of file
+#       14: trailing-whitespace  trailing whitespace
+#
+#   ✖ 3 whitespace issues in 2 files  (missing-final-newline=1, mixed-eol=1, trailing-whitespace=1)
+
+pipx run wssweep --fix   # clean them in place
+```
+
+No config file, no framework. Exits non-zero when it finds issues, so it drops
+straight into CI. Pure standard library. Also on npm (`npx wssweep`) — the two
+builds produce **byte-for-byte identical** output *and* identical fixes.
+
+## Why another whitespace tool?
+
+Because today this takes three or four tools wired together:
+
+- **editorconfig-checker** reports, but needs you to author an `.editorconfig`
+  first, and it can't fix anything.
+- **pre-commit**'s `trailing-whitespace` / `end-of-file-fixer` /
+  `mixed-line-ending` hooks *do* fix — but only inside the pre-commit framework,
+  and they're three separate hooks. Nobody runs them ad-hoc on a fresh checkout.
+- **prettier** fixes whitespace only as a side effect of reformatting all your
+  code, is language-aware, and won't touch files it can't parse.
+- **dos2unix** only does line endings.
+
+`wssweep` is the one command — `pip`/`npx`, zero config — that reports *all*
+seven whitespace smells at once with line numbers and optionally fixes them in
+place, with a clean CI exit code, identical on Python and Node.
+
+## What it checks
+
+| check | what | `--fix` |
+|---|---|---|
+| `trailing-whitespace` | space/tab at end of a line | trims it |
+| `mixed-eol` | a file containing **both** CRLF and LF | normalizes to LF |
+| `lone-cr` | a bare CR (old-Mac line ending) | normalizes |
+| `missing-final-newline` | non-empty file not ending in a newline | appends one |
+| `trailing-blank-lines` | extra blank line(s) at end of file | collapses to one |
+| `utf8-bom` | a leading UTF-8 BOM | strips it |
+| `mixed-indentation` | tabs **and** spaces in one indent | report-only (needs your tab width) |
+
+Opinionated, zero-config defaults: a consistently-CRLF file is **fine** (only
+*mixed* endings are flagged), `.bat`/`.cmd` keep CRLF when fixed, and Markdown's
+two-trailing-spaces hard line break is preserved (trailing-whitespace is skipped
+in `.md`).
+
+## Usage
+
+```bash
+wssweep                       # scan the current directory
+wssweep src/ docs/            # scan specific paths
+wssweep --fix                 # fix in place (atomic; only files that change)
+wssweep --crlf --fix          # normalize endings to CRLF instead of LF
+wssweep --skip=mixed-indentation   # turn off a check
+wssweep --exclude='*.min.js'  # skip paths by glob (repeatable)
+wssweep --json                # machine output (byte-identical both builds)
+```
+
+`.git`, `node_modules`, `dist`, `build`, `vendor`, `.venv` and friends are
+skipped by default, as are binary files (detected by extension + a NUL-byte /
+non-UTF-8 content check) and files over 5 MB. `--all` overrides those skips.
+
+Exit codes: `0` clean · `1` issues found · `2` error. (`--fix` exits `0` once
+everything fixable is fixed; a leftover `mixed-indentation` keeps it `1`.)
+
+## How it works
+
+It reads every file as **raw bytes** and scans a byte-faithful (latin-1) view, so
+it never mangles encodings and the Python and Node builds agree to the byte: line
+endings are classified from the bytes (never `splitlines`, which over-splits),
+"whitespace" means exactly space and tab (never `\s`, which differs across
+languages), and `--fix` writes raw bytes atomically (temp file + rename),
+touching only files that actually change and preserving file modes. Fixing is
+idempotent — run it twice, the second run does nothing.
+
+## Install
+
+```bash
+pip install wssweep  # or pipx run wssweep
+npm i -g wssweep     # Node build, identical behaviour
+```
+
+Python ≥ 3.8 or Node ≥ 18. No dependencies.
+
+## License
+
+MIT

wssweep-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wssweep"
+version = "0.1.0"
+description = "Zero-config whitespace doctor: find (and --fix) trailing whitespace, mixed line endings, missing/extra final newlines, BOMs and mixed indentation. Zero dependencies."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "yyfjj" }]
+keywords = ["whitespace", "trailing-whitespace", "line-endings", "crlf", "eol", "lint", "formatter", "cli", "ci"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Utilities",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/jjdoor/wssweep-py"
+Repository = "https://github.com/jjdoor/wssweep-py"
+Issues = "https://github.com/jjdoor/wssweep-py/issues"
+
+[project.scripts]
+wssweep = "wssweep.cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

wssweep-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wssweep-0.1.0/src/wssweep/__init__.py

@@ -0,0 +1,3 @@
+"""wssweep — zero-config whitespace doctor: find and --fix whitespace problems. Zero dependencies."""
+
+__version__ = "0.1.0"

wssweep-0.1.0/src/wssweep/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

wssweep-0.1.0/src/wssweep/cli.py

@@ -0,0 +1,172 @@
+import json
+import os
+import signal
+import sys
+
+from . import __version__
+from . import core
+from . import walk as walkmod
+
+
+def _mk_paint(on):
+    def col(c, s):
+        return f"\x1b[{c}m{s}\x1b[0m" if on else s
+    return {
+        "red": lambda s: col("31", s), "green": lambda s: col("32", s),
+        "yellow": lambda s: col("33", s), "dim": lambda s: col("2", s),
+        "bold": lambda s: col("1", s), "cyan": lambda s: col("36", s),
+    }
+
+
+def _help(p):
+    b = p["bold"]
+    return (
+        f"{b('wssweep')} — find (and --fix) whitespace problems. Zero config, zero dependencies.\n"
+        "\n"
+        "Reports trailing whitespace, mixed CRLF/LF line endings, a missing final newline,\n"
+        "extra trailing blank lines, a UTF-8 BOM, lone CRs, and mixed tabs/spaces in indents.\n"
+        "\n"
+        f"{b('Usage')}\n"
+        "  wssweep [path...]      Scan paths (default: current directory)\n"
+        "  wssweep --fix          Fix the issues in place (atomic, only changed files)\n"
+        "  wssweep --json         Machine-readable output, for CI\n"
+        "\n"
+        f"{b('Options')}\n"
+        "  --fix              Rewrite files in place (off by default — report only)\n"
+        "  --crlf             When fixing, normalize line endings to CRLF instead of LF\n"
+        "  --skip=a,b         Skip checks (e.g. --skip=mixed-indentation)\n"
+        "  --exclude=<glob>   Skip paths matching a glob (repeatable; e.g. --exclude='*.min.js')\n"
+        "  --all              Scan vendored dirs + large/binary-extension files too\n"
+        "  --json             JSON output (byte-identical across the Node and Python builds)\n"
+        "  --quiet            Print only the summary line\n"
+        "  --no-color         Disable ANSI color\n"
+        "  --help | --version\n"
+        "\n"
+        f"{b('Checks')}  trailing-whitespace · mixed-eol · lone-cr · missing-final-newline · trailing-blank-lines · utf8-bom · mixed-indentation\n"
+        f"{b('Exit')}  0 clean · 1 issues found · 2 error\n"
+    )
+
+
+def main(argv=None):
+    try:
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+    except (AttributeError, ValueError):
+        pass
+
+    argv = list(sys.argv[1:] if argv is None else argv)
+    use_color = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
+
+    def die(msg):
+        sys.stderr.write(_mk_paint(use_color)["red"](f"wssweep: {msg}\n"))
+        return 2
+
+    dd_idx = argv.index("--") if "--" in argv else len(argv)
+    pre = argv[:dd_idx]
+    if "-h" in pre or "--help" in pre:
+        sys.stdout.write(_help(_mk_paint(use_color)))
+        return 0
+    if "-v" in pre or "--version" in pre:
+        sys.stdout.write(__version__ + "\n")
+        return 0
+
+    do_fix = crlf = as_json = quiet = no_color = all_ = False
+    roots, excludes = [], []
+    skip = set()
+    dd = False
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if dd:
+            roots.append(a); i += 1; continue
+        if a == "--":
+            dd = True; i += 1; continue
+        eq = a.find("=") if a.startswith("--") else -1
+        flag = a[:eq] if eq != -1 else a
+        inline = a[eq + 1:] if eq != -1 else None
+
+        def take():
+            nonlocal i
+            if inline is not None:
+                return inline
+            i += 1
+            return argv[i] if i < len(argv) else ""
+
+        if flag == "--fix":
+            do_fix = True
+        elif flag == "--crlf":
+            crlf = True
+        elif flag == "--json":
+            as_json = True
+        elif flag == "--quiet":
+            quiet = True
+        elif flag == "--no-color":
+            no_color = True
+        elif flag == "--all":
+            all_ = True
+        elif flag == "--skip":
+            for x in take().split(","):
+                x = x.strip()
+                if x:
+                    skip.add(x)
+        elif flag == "--exclude":
+            v = take()
+            if v:
+                excludes.append(v)
+        elif a in ("-h", "--help", "-v", "--version"):
+            pass
+        elif a.startswith("-") and a != "-":
+            return die(f"unknown option: {a} (use -- to end options)")
+        else:
+            roots.append(a)
+        i += 1
+
+    if not roots:
+        roots.append(".")
+    paint = _mk_paint(use_color and not no_color)
+
+    for r in roots:
+        if not walkmod.root_exists(r):
+            return die(f"cannot access '{r}'")
+
+    try:
+        files = walkmod.collect_files(roots, {"all": all_, "exclude": excludes})
+    except OSError as e:
+        return die(str(e))
+
+    records = []
+    files_scanned = 0
+    for f in files:
+        buf = walkmod.read_file_bytes(f, all_)
+        if buf is None:
+            continue
+        files_scanned += 1
+        ext = walkmod.ext_of(f)
+        s = walkmod.bytes_to_latin1(buf)
+        issues = [iss for iss in core.analyze(s, ext) if iss["check"] not in skip]
+        if do_fix and core.has_fixable_issue(issues):
+            out = core.fix(s, ext, {"crlf": crlf, "skip": skip})
+            if out != s:
+                try:
+                    walkmod.write_file_atomic(f, walkmod.latin1_to_bytes(out))
+                except OSError as e:
+                    return die(str(e))
+        posix = walkmod.to_posix(f)
+        for iss in issues:
+            records.append({"file": posix, "check": iss["check"], "line": iss["line"], "message": iss["message"]})
+
+    records = core.sort_file_issues(records)
+    summary = core.summarize(records, files_scanned)
+
+    if as_json:
+        sys.stdout.write(json.dumps(core.to_json(records, summary), indent=2, ensure_ascii=False) + "\n")
+    elif do_fix:
+        remaining = [r for r in records if r["check"] not in core.FIXABLE]
+        sys.stdout.write(core.format_report(records, summary, paint, {"quiet": quiet, "fixed": True}) + "\n")
+        if remaining:
+            sys.stdout.write(paint["yellow"](f"  {len(remaining)} issue(s) need manual fixing (not auto-fixable)") + "\n")
+    else:
+        sys.stdout.write(core.format_report(records, summary, paint, {"quiet": quiet}) + "\n")
+
+    if do_fix:
+        return 1 if any(r["check"] not in core.FIXABLE for r in records) else 0
+    return 1 if records else 0

wssweep-0.1.0/src/wssweep/core.py

@@ -0,0 +1,188 @@
+"""wssweep core — pure whitespace detection & fixing. No fs, no walking.
+
+Everything operates on a LATIN-1 (byte-faithful) string: each byte 0x00–0xFF maps
+to one code point, reversibly, so the Node and Python builds see the exact same
+bytes and emit byte-for-byte identical output. We never use \\s (Unicode-divergent),
+never str.splitlines (over-splits on VT/FF/NEL/LS/PS), and never a text-mode reader
+(would translate newlines). The CLI converts file bytes <-> latin1 string at the IO
+boundary. Trailing-ws regex uses \\Z (not $) to match JS's end-of-string $ exactly.
+
+Checks (all default on): trailing-whitespace, mixed-eol, lone-cr,
+missing-final-newline, trailing-blank-lines, utf8-bom, mixed-indentation.
+"""
+
+import re
+
+BOM = "\xef\xbb\xbf"  # UTF-8 BOM EF BB BF in latin1
+CRLF_EXTS = {"bat", "cmd", "ps1", "sln", "csproj", "vcxproj", "props"}
+MD_EXTS = {"md", "markdown"}
+
+CHECK_ORDER = {
+    "utf8-bom": 0, "mixed-eol": 1, "lone-cr": 2, "missing-final-newline": 3,
+    "trailing-blank-lines": 4, "trailing-whitespace": 5, "mixed-indentation": 6,
+}
+
+_EOL_RE = re.compile(r"\r\n|\r|\n")
+_TRAIL_RE = re.compile(r"[ \t]+\Z")
+_BLANK_RE = re.compile(r"[ \t]*\Z")
+_INDENT_RE = re.compile(r"[ \t]*")
+
+
+def count_sub(s, sub):
+    return s.count(sub) if sub else 0
+
+
+def split_physical_lines(s):
+    return _EOL_RE.split(s)
+
+
+def analyze(s, ext):
+    issues = []
+    is_md = ext in MD_EXTS
+    has_bom = s.startswith(BOM)
+    body = s[3:] if has_bom else s
+    if has_bom:
+        issues.append({"check": "utf8-bom", "line": None, "message": "UTF-8 BOM"})
+
+    crlf = count_sub(body, "\r\n")
+    lone_lf = count_sub(body, "\n") - crlf
+    lone_cr = count_sub(body, "\r") - crlf
+    if crlf > 0 and lone_lf > 0:
+        issues.append({"check": "mixed-eol", "line": None, "message": f"mixed line endings (CRLF×{crlf}, LF×{lone_lf})"})
+    if lone_cr > 0:
+        issues.append({"check": "lone-cr", "line": None, "message": f"{lone_cr} bare CR"})
+
+    lines = split_physical_lines(body)
+    ends_with_newline = len(body) > 0 and lines[-1] == ""
+
+    for i, line in enumerate(lines):
+        if not is_md and _TRAIL_RE.search(line):
+            issues.append({"check": "trailing-whitespace", "line": i + 1, "message": "trailing whitespace"})
+        indent = _INDENT_RE.match(line).group(0)
+        if " " in indent and "\t" in indent:
+            issues.append({"check": "mixed-indentation", "line": i + 1, "message": "mixed tabs and spaces in indent"})
+
+    if len(body) > 0 and not body.endswith("\n") and not body.endswith("\r"):
+        issues.append({"check": "missing-final-newline", "line": None, "message": "no newline at end of file"})
+
+    if ends_with_newline:
+        content = lines[:-1]
+        k = 0
+        for j in range(len(content) - 1, -1, -1):
+            if _BLANK_RE.fullmatch(content[j]):
+                k += 1
+            else:
+                break
+        if k >= 1:
+            issues.append({"check": "trailing-blank-lines", "line": None, "message": f"{k} trailing blank line{'' if k == 1 else 's'}"})
+
+    issues.sort(key=lambda a: (a["line"] if a["line"] is not None else 0, CHECK_ORDER[a["check"]]))
+    return issues
+
+
+FIXABLE = {"utf8-bom", "mixed-eol", "lone-cr", "missing-final-newline", "trailing-blank-lines", "trailing-whitespace"}
+
+
+def has_fixable_issue(issues):
+    return any(i["check"] in FIXABLE for i in issues)
+
+
+def fix(s, ext, opts=None):
+    opts = opts or {}
+    skip = opts.get("skip") or set()
+    is_md = ext in MD_EXTS
+    has_bom = s.startswith(BOM)
+    strip_bom = has_bom and "utf8-bom" not in skip
+    body = s[3:] if strip_bom else s
+    if len(body) == 0:
+        return ""
+    skip_trailing = is_md or "trailing-whitespace" in skip
+
+    crlf = count_sub(body, "\r\n")
+    lone_lf = count_sub(body, "\n") - crlf
+    lone_cr = count_sub(body, "\r") - crlf
+    consistent_crlf = crlf > 0 and lone_lf == 0 and lone_cr == 0
+    eol = "\r\n" if (opts.get("crlf") or ext in CRLF_EXTS or consistent_crlf) else "\n"
+
+    lines = split_physical_lines(body)
+    ends_with_newline = lines[-1] == ""
+    content = lines[:-1] if ends_with_newline else lines
+    fixed = [l if skip_trailing else _TRAIL_RE.sub("", l) for l in content]
+    while fixed and _BLANK_RE.fullmatch(fixed[-1]):
+        fixed.pop()
+    out = eol.join(fixed)
+    if fixed:
+        out += eol
+    return out
+
+
+# ---- rendering -------------------------------------------------------------
+
+PLAIN = {"red": lambda s: s, "green": lambda s: s, "yellow": lambda s: s,
+         "dim": lambda s: s, "bold": lambda s: s, "cyan": lambda s: s}
+
+
+def sort_file_issues(records):
+    return sorted(records, key=lambda r: (r["file"].encode("utf-8"),
+                                          r["line"] if r["line"] is not None else 0,
+                                          CHECK_ORDER[r["check"]]))
+
+
+def summarize(records, files_scanned):
+    by_type = {}
+    for r in records:
+        by_type[r["check"]] = by_type.get(r["check"], 0) + 1
+    files = {r["file"] for r in records}
+    return {"filesScanned": files_scanned, "filesWithIssues": len(files), "issueCount": len(records), "byType": by_type}
+
+
+def to_json(records, summary):
+    by_file = {}
+    order = []
+    for r in records:
+        if r["file"] not in by_file:
+            by_file[r["file"]] = []
+            order.append(r["file"])
+        by_file[r["file"]].append({"check": r["check"], "line": r["line"], "message": r["message"]})
+    return {"version": 1, "summary": summary, "files": [{"path": f, "issues": by_file[f]} for f in order]}
+
+
+def format_report(records, summary, paint=None, opts=None):
+    p = paint or PLAIN
+    opts = opts or {}
+    quiet = opts.get("quiet")
+    fixed = opts.get("fixed")
+    if not records:
+        n = summary["filesScanned"]
+        return p["green"]("✓ no whitespace issues") + f" ({n} file{'' if n == 1 else 's'} scanned)"
+    lines = []
+    if not quiet:
+        current = None
+        for r in records:
+            if r["file"] != current:
+                if current is not None:
+                    lines.append("")
+                current = r["file"]
+                n = sum(1 for x in records if x["file"] == r["file"])
+                lines.append(p["bold"](r["file"]) + p["dim"](f"  ({n})"))
+            loc = p["dim"]("   -  ") if r["line"] is None else p["dim"](str(r["line"]).rjust(4) + ":")
+            verb = p["green"]("fixed ") if (fixed and r["check"] in FIXABLE) else ""
+            lines.append(f"  {loc} {verb}{p['cyan'](r['check'])}  {p['dim'](r['message'])}")
+        lines.append("")
+    if fixed:
+        # Count only the issues actually auto-fixed (report-only checks like
+        # mixed-indentation never change bytes and aren't "fixed").
+        fix_recs = [r for r in records if r["check"] in FIXABLE]
+        fc = len(fix_recs)
+        ff = len({r["file"] for r in fix_recs})
+        by_type = {}
+        for r in fix_recs:
+            by_type[r["check"]] = by_type.get(r["check"], 0) + 1
+        types = ", ".join(f"{k}={by_type[k]}" for k in sorted(by_type))
+        lines.append(p["green"](f"✓ fixed {fc} issue{'' if fc == 1 else 's'} in {ff} file{'' if ff == 1 else 's'}") + (p["dim"](f"  ({types})") if types else ""))
+    else:
+        ic = summary["issueCount"]
+        fi = summary["filesWithIssues"]
+        types = ", ".join(f"{k}={summary['byType'][k]}" for k in sorted(summary["byType"]))
+        lines.append(p["red"](f"✖ {ic} whitespace issue{'' if ic == 1 else 's'} in {fi} file{'' if fi == 1 else 's'}") + p["dim"](f"  ({types})"))
+    return "\n".join(lines)

wssweep-0.1.0/src/wssweep/walk.py

@@ -0,0 +1,152 @@
+"""wssweep IO — directory walking and raw-byte file reading. No whitespace logic.
+
+Both builds must discover the SAME file set (same ignore dirs, same binary skip by
+extension + content, same symlink policy, same size cap, same glob exclude) and read
+RAW BYTES (never text mode, which would translate newlines).
+"""
+
+import os
+import re
+import stat as _stat
+
+IGNORE_DIRS = {
+    ".git", ".svn", ".hg", "node_modules", "vendor", "dist", "build", "out",
+    "target", ".venv", "venv", ".tox", "coverage", ".next", ".nuxt", ".cache",
+}
+
+BINARY_EXTS = {
+    "png", "jpg", "jpeg", "gif", "webp", "ico", "bmp", "tiff", "pdf",
+    "zip", "gz", "tgz", "tar", "bz2", "xz", "7z", "rar", "jar", "war", "wasm",
+    "woff", "woff2", "ttf", "otf", "eot", "mp4", "mov", "avi", "webm", "mkv",
+    "mp3", "wav", "flac", "ogg", "exe", "dll", "so", "dylib", "o", "a", "class",
+    "bin", "dat", "db", "sqlite", "pyc", "pyo", "node", "lock",
+}
+
+SIZE_CAP = 5 * 1024 * 1024
+
+_GLOB_SPECIAL = set("\\^$.|+()[]{}")
+
+
+def to_posix(p):
+    s = p.replace(os.sep, "/")
+    return s[2:] if s.startswith("./") else s
+
+
+def ext_of(p):
+    return os.path.splitext(p)[1][1:].lower()
+
+
+def root_exists(p):
+    try:
+        os.stat(p)
+        return True
+    except OSError:
+        return False
+
+
+def glob_to_re(glob):
+    out = []
+    i = 0
+    while i < len(glob):
+        c = glob[i]
+        if c == "*":
+            if i + 1 < len(glob) and glob[i + 1] == "*":
+                out.append(".*"); i += 1
+            else:
+                out.append("[^/]*")
+        elif c == "?":
+            out.append("[^/]")
+        elif c in _GLOB_SPECIAL:
+            out.append("\\" + c)
+        else:
+            out.append(c)
+        i += 1
+    return re.compile("".join(out))
+
+
+def make_excluder(patterns):
+    compiled = [(glob_to_re(g), "/" not in g) for g in (patterns or []) if g]
+
+    def excluded(posix_path):
+        base = posix_path.split("/")[-1]
+        return any(rx.fullmatch(base if is_base else posix_path) for rx, is_base in compiled)
+
+    return excluded
+
+
+def collect_files(roots, opts=None):
+    opts = opts or {}
+    all_ = bool(opts.get("all"))
+    excluded = make_excluder(opts.get("exclude"))
+    out = []
+
+    def visit(p, is_root):
+        try:
+            st = os.stat(p) if is_root else os.lstat(p)
+        except OSError:
+            return
+        if not is_root and _stat.S_ISLNK(st.st_mode):
+            return
+        posix = to_posix(p)
+        if _stat.S_ISDIR(st.st_mode):
+            if not is_root and ((not all_ and os.path.basename(p) in IGNORE_DIRS) or excluded(posix)):
+                return
+            try:
+                entries = os.listdir(p)
+            except OSError:
+                return
+            entries.sort(key=lambda n: n.encode("utf-8"))
+            for e in entries:
+                visit(os.path.join(p, e), False)
+        elif _stat.S_ISREG(st.st_mode):
+            if not is_root and excluded(posix):
+                return
+            if not all_ and ext_of(p) in BINARY_EXTS:
+                return
+            out.append(p)
+
+    for r in roots:
+        visit(r, True)
+    return out
+
+
+def read_file_bytes(p, all_):
+    try:
+        with open(p, "rb") as fh:
+            buf = fh.read()
+    except OSError:
+        return None
+    if not all_ and len(buf) > SIZE_CAP:
+        return None
+    if b"\x00" in buf[:8192]:
+        return None
+    try:
+        buf.decode("utf-8")
+    except UnicodeDecodeError:
+        return None
+    return buf
+
+
+def bytes_to_latin1(buf):
+    return buf.decode("latin-1")
+
+
+def latin1_to_bytes(s):
+    return s.encode("latin-1")
+
+
+def write_file_atomic(p, data):
+    d = os.path.dirname(p) or "."
+    tmp = os.path.join(d, ".wssweep-%d-%s.tmp" % (os.getpid(), os.path.basename(p)))
+    try:
+        mode = os.stat(p).st_mode
+    except OSError:
+        mode = None
+    with open(tmp, "wb") as fh:
+        fh.write(data)
+    if mode is not None:
+        try:
+            os.chmod(tmp, mode)
+        except OSError:
+            pass
+    os.replace(tmp, p)

wssweep-0.1.0/src/wssweep.egg-info/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: wssweep
+Version: 0.1.0
+Summary: Zero-config whitespace doctor: find (and --fix) trailing whitespace, mixed line endings, missing/extra final newlines, BOMs and mixed indentation. Zero dependencies.
+Author: yyfjj
+License: MIT
+Project-URL: Homepage, https://github.com/jjdoor/wssweep-py
+Project-URL: Repository, https://github.com/jjdoor/wssweep-py
+Project-URL: Issues, https://github.com/jjdoor/wssweep-py/issues
+Keywords: whitespace,trailing-whitespace,line-endings,crlf,eol,lint,formatter,cli,ci
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# wssweep
+
+**A zero-config whitespace doctor.** Run it on any repo and it instantly finds —
+and with `--fix`, cleans — the whitespace problems that pollute diffs and break
+across platforms: trailing whitespace, mixed CRLF/LF line endings, a missing
+final newline, extra trailing blank lines, a UTF-8 BOM, lone CRs, and tabs mixed
+with spaces in indentation.
+
+```bash
+pipx run wssweep
+#   config.yml  (1)
+#        -  mixed-eol  mixed line endings (CRLF×3, LF×1)
+#
+#   src/app.js  (2)
+#        -  missing-final-newline  no newline at end of file
+#       14: trailing-whitespace  trailing whitespace
+#
+#   ✖ 3 whitespace issues in 2 files  (missing-final-newline=1, mixed-eol=1, trailing-whitespace=1)
+
+pipx run wssweep --fix   # clean them in place
+```
+
+No config file, no framework. Exits non-zero when it finds issues, so it drops
+straight into CI. Pure standard library. Also on npm (`npx wssweep`) — the two
+builds produce **byte-for-byte identical** output *and* identical fixes.
+
+## Why another whitespace tool?
+
+Because today this takes three or four tools wired together:
+
+- **editorconfig-checker** reports, but needs you to author an `.editorconfig`
+  first, and it can't fix anything.
+- **pre-commit**'s `trailing-whitespace` / `end-of-file-fixer` /
+  `mixed-line-ending` hooks *do* fix — but only inside the pre-commit framework,
+  and they're three separate hooks. Nobody runs them ad-hoc on a fresh checkout.
+- **prettier** fixes whitespace only as a side effect of reformatting all your
+  code, is language-aware, and won't touch files it can't parse.
+- **dos2unix** only does line endings.
+
+`wssweep` is the one command — `pip`/`npx`, zero config — that reports *all*
+seven whitespace smells at once with line numbers and optionally fixes them in
+place, with a clean CI exit code, identical on Python and Node.
+
+## What it checks
+
+| check | what | `--fix` |
+|---|---|---|
+| `trailing-whitespace` | space/tab at end of a line | trims it |
+| `mixed-eol` | a file containing **both** CRLF and LF | normalizes to LF |
+| `lone-cr` | a bare CR (old-Mac line ending) | normalizes |
+| `missing-final-newline` | non-empty file not ending in a newline | appends one |
+| `trailing-blank-lines` | extra blank line(s) at end of file | collapses to one |
+| `utf8-bom` | a leading UTF-8 BOM | strips it |
+| `mixed-indentation` | tabs **and** spaces in one indent | report-only (needs your tab width) |
+
+Opinionated, zero-config defaults: a consistently-CRLF file is **fine** (only
+*mixed* endings are flagged), `.bat`/`.cmd` keep CRLF when fixed, and Markdown's
+two-trailing-spaces hard line break is preserved (trailing-whitespace is skipped
+in `.md`).
+
+## Usage
+
+```bash
+wssweep                       # scan the current directory
+wssweep src/ docs/            # scan specific paths
+wssweep --fix                 # fix in place (atomic; only files that change)
+wssweep --crlf --fix          # normalize endings to CRLF instead of LF
+wssweep --skip=mixed-indentation   # turn off a check
+wssweep --exclude='*.min.js'  # skip paths by glob (repeatable)
+wssweep --json                # machine output (byte-identical both builds)
+```
+
+`.git`, `node_modules`, `dist`, `build`, `vendor`, `.venv` and friends are
+skipped by default, as are binary files (detected by extension + a NUL-byte /
+non-UTF-8 content check) and files over 5 MB. `--all` overrides those skips.
+
+Exit codes: `0` clean · `1` issues found · `2` error. (`--fix` exits `0` once
+everything fixable is fixed; a leftover `mixed-indentation` keeps it `1`.)
+
+## How it works
+
+It reads every file as **raw bytes** and scans a byte-faithful (latin-1) view, so
+it never mangles encodings and the Python and Node builds agree to the byte: line
+endings are classified from the bytes (never `splitlines`, which over-splits),
+"whitespace" means exactly space and tab (never `\s`, which differs across
+languages), and `--fix` writes raw bytes atomically (temp file + rename),
+touching only files that actually change and preserving file modes. Fixing is
+idempotent — run it twice, the second run does nothing.
+
+## Install
+
+```bash
+pip install wssweep  # or pipx run wssweep
+npm i -g wssweep     # Node build, identical behaviour
+```
+
+Python ≥ 3.8 or Node ≥ 18. No dependencies.
+
+## License
+
+MIT

wssweep-0.1.0/src/wssweep.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/wssweep/__init__.py
+src/wssweep/__main__.py
+src/wssweep/cli.py
+src/wssweep/core.py
+src/wssweep/walk.py
+src/wssweep.egg-info/PKG-INFO
+src/wssweep.egg-info/SOURCES.txt
+src/wssweep.egg-info/dependency_links.txt
+src/wssweep.egg-info/entry_points.txt
+src/wssweep.egg-info/top_level.txt
+tests/test_core.py

wssweep-0.1.0/src/wssweep.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wssweep-0.1.0/src/wssweep.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wssweep = wssweep.cli:main

wssweep-0.1.0/src/wssweep.egg-info/top_level.txt

@@ -0,0 +1 @@
+wssweep

wssweep-0.1.0/tests/test_core.py

@@ -0,0 +1,123 @@
+from wssweep import core
+
+
+def checks(s, ext="txt"):
+    return [i["check"] for i in core.analyze(s, ext)]
+
+
+def fix(s, ext="txt", opts=None):
+    return core.fix(s, ext, opts)
+
+
+def test_trailing_whitespace_per_line():
+    f = core.analyze("foo  \nbar\t\nbaz\n", "txt")
+    assert [i["line"] for i in f if i["check"] == "trailing-whitespace"] == [1, 2]
+
+
+def test_trailing_ws_before_crlf():
+    assert checks("x  \r\n") == ["trailing-whitespace"]
+
+
+def test_mixed_eol():
+    assert checks("a\r\nb\nc\r\n") == ["mixed-eol"]
+    assert checks("a\r\nb\r\n") == []
+    assert checks("a\nb\n") == []
+
+
+def test_lone_cr():
+    assert checks("a\rb\rc\n") == ["lone-cr"]
+    assert checks("a\r\nb\r\n") == []
+
+
+def test_missing_final_newline():
+    assert checks("x") == ["missing-final-newline"]
+    assert checks("") == []
+    assert checks("x\n") == []
+
+
+def test_trailing_blank_lines():
+    assert checks("x\n\n\n") == ["trailing-blank-lines"]
+    assert checks("x\n") == []
+    assert sorted(checks("x\n   \n")) == ["trailing-blank-lines", "trailing-whitespace"]
+
+
+def test_bom():
+    assert checks("\xef\xbb\xbfhi\n") == ["utf8-bom"]
+    assert fix("\xef\xbb\xbfhi\n") == "hi\n"
+
+
+def test_mixed_indentation():
+    assert checks("\t  x\n", "py") == ["mixed-indentation"]
+    assert checks("  \tx\n", "py") == ["mixed-indentation"]
+    assert checks("x = 1\t# aligned\n", "py") == []
+
+
+def test_markdown_skip_trailing_ws():
+    assert checks("line one  \nline two\n", "md") == []
+    assert fix("line one  \nline two\n", "md") == "line one  \nline two\n"
+
+
+def test_fix_normalizes():
+    assert fix("a  \r\nb\n\n\n") == "a\nb\n"
+
+
+def test_fix_keeps_consistent_crlf():
+    assert fix("a  \r\nb\r\n") == "a\r\nb\r\n"
+
+
+def test_fix_bat_forced_crlf():
+    assert fix("a\nb\n", "bat") == "a\r\nb\r\n"
+
+
+def test_fix_crlf_idempotent():
+    once = fix("a  \nb", "txt", {"crlf": True})
+    assert once == "a\r\nb\r\n"
+    assert fix(once, "txt", {"crlf": True}) == once
+
+
+def test_fix_final_newline_and_empty():
+    assert fix("x") == "x\n"
+    assert fix("") == ""
+
+
+def test_fix_respects_skip():
+    assert fix("a  \n", "txt", {"skip": {"trailing-whitespace"}}) == "a  \n"
+    assert fix("\xef\xbb\xbfhi\n", "txt", {"skip": {"utf8-bom"}}) == "\xef\xbb\xbfhi\n"
+
+
+def test_fix_idempotent_full():
+    once = fix("\xef\xbb\xbfa  \r\nb\n\n\n")
+    assert fix(once) == once
+
+
+def test_json_and_summarize():
+    recs = core.sort_file_issues([
+        {"file": "b.txt", "check": "utf8-bom", "line": None, "message": "m"},
+        {"file": "a.txt", "check": "trailing-whitespace", "line": 2, "message": "m"},
+        {"file": "a.txt", "check": "trailing-whitespace", "line": 1, "message": "m"},
+    ])
+    assert [f"{r['file']}:{r['line']}" for r in recs] == ["a.txt:1", "a.txt:2", "b.txt:None"]
+    sum_ = core.summarize(recs, 2)
+    assert sum_ == {"filesScanned": 2, "filesWithIssues": 2, "issueCount": 3, "byType": {"trailing-whitespace": 2, "utf8-bom": 1}}
+    j = core.to_json(recs, sum_)
+    assert j["version"] == 1
+    assert j["files"][0]["path"] == "a.txt"
+    assert len(j["files"][0]["issues"]) == 2
+
+
+def test_fix_mode_excludes_report_only():
+    recs = core.sort_file_issues([
+        {"file": "a.py", "check": "mixed-indentation", "line": 2, "message": "mixed"},
+        {"file": "a.py", "check": "trailing-whitespace", "line": 1, "message": "trailing whitespace"},
+    ])
+    out = core.format_report(recs, core.summarize(recs, 1), None, {"fixed": True})
+    assert "✓ fixed 1 issue in 1 file" in out
+    assert "fixed trailing-whitespace" in out
+    assert "fixed mixed-indentation" not in out
+    assert "(trailing-whitespace=1)" in out
+
+
+def test_format_report():
+    assert "no whitespace issues" in core.format_report([], core.summarize([], 3), None, {})
+    recs = [{"file": "a.txt", "check": "utf8-bom", "line": None, "message": "UTF-8 BOM"}]
+    assert "1 whitespace issue in 1 file" in core.format_report(recs, core.summarize(recs, 1), None, {})