hexsweep 0.1.0__py3-none-any.whl

hexsweep/__init__.py

@@ -0,0 +1,3 @@
+"""hexsweep — find hardcoded colors that should be design tokens. Zero dependencies."""
+
+__version__ = "0.1.0"

hexsweep/__main__.py

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

hexsweep/cli.py

@@ -0,0 +1,141 @@
+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('hexsweep')} — find hardcoded colors that should be design tokens. Zero dependencies.\n"
+        "\n"
+        "Scans your source for raw color literals (#hex, rgb()/hsl()) that escaped a\n"
+        "design-token migration — the `background: #3f82f0` that should be `var(--primary)`.\n"
+        "Token definitions (`--primary: #3f82f0`) are allowed by default; usages are flagged.\n"
+        "\n"
+        f"{b('Usage')}\n"
+        "  hexsweep [path...]          Scan paths (default: current directory)\n"
+        "  hexsweep src/ --json        Machine-readable output, for CI\n"
+        "\n"
+        f"{b('Options')}\n"
+        "  --ext css,scss,tsx     Override the scanned extension set\n"
+        "  --allow \"#000,#fff\"    Allowlist literals that are OK to hardcode\n"
+        "  --strict               Also flag token DEFINITIONS (--x/$x/@x), not just usages\n"
+        "  --exclude dirA,dirB    Extra directory names to skip (node_modules/.git/dist… already skipped)\n"
+        "  --json                 JSON output (byte-identical across the Node and Python builds)\n"
+        "  --quiet                Only print the summary line\n"
+        "  --no-color             Disable ANSI color\n"
+        "  --help | --version\n"
+        "\n"
+        f"{b('Exit')}  0 clean · 1 hardcoded colors 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"hexsweep: {msg}\n"))
+        return 2
+
+    dd_idx = argv.index("--") if "--" in argv else len(argv)
+    pre_argv = argv[:dd_idx]
+    if "-h" in pre_argv or "--help" in pre_argv:
+        sys.stdout.write(_help(_mk_paint(use_color)))
+        return 0
+    if "-v" in pre_argv or "--version" in pre_argv:
+        sys.stdout.write(__version__ + "\n")
+        return 0
+
+    as_json = strict = quiet = no_color = False
+    exts = None
+    allow_list = []
+    exclude_dirs = []
+    roots = []
+    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("=")
+        flag = a[:eq] if (a.startswith("--") and eq != -1) else a
+        inline = a[eq + 1:] if (a.startswith("--") and 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 == "--json":
+            as_json = True
+        elif flag == "--strict":
+            strict = True
+        elif flag == "--quiet":
+            quiet = True
+        elif flag == "--no-color":
+            no_color = True
+        elif flag == "--ext":
+            exts = [t for t in (s.strip().lstrip(".") for s in take().split(",")) if t]
+        elif flag == "--allow":
+            allow_list += core.split_color_list(take())
+        elif flag == "--exclude":
+            exclude_dirs += [s.strip() for s in take().split(",") if s.strip()]
+        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(".")
+    scan_exts = exts if exts else walkmod.DEFAULT_EXTS
+    allow = core.build_allow(allow_list)
+    paint = _mk_paint(use_color and not no_color)
+
+    try:
+        files = walkmod.collect_files(roots, scan_exts, exclude_dirs)
+    except OSError as e:
+        return die(str(e))
+
+    findings = []
+    for f in files:
+        text = walkmod.read_file_text(f)
+        if text is None:
+            continue
+        ext = (f.rsplit(".", 1)[-1] if "." in f else "").lower()
+        findings += core.scan_text(text, walkmod.to_posix(f), ext, {"allow": allow, "strict": strict})
+    findings = core.sort_findings(findings)
+    summary = core.summarize(findings, len(files))
+
+    if as_json:
+        sys.stdout.write(json.dumps(core.to_json(findings, summary), indent=2, ensure_ascii=False) + "\n")
+    else:
+        sys.stdout.write(core.format_report(findings, summary, paint, {"quiet": quiet}) + "\n")
+    return 1 if findings else 0

hexsweep/core.py

@@ -0,0 +1,262 @@
+"""hexsweep core — pure scanning logic. No fs, no walking, no clock.
+
+Finds hardcoded color literals (hex + rgb/hsl functional notation) that should be
+design tokens. The differentiation vs a raw grep lives here: comment-aware
+blanking (but strings are KEPT, since CSS-in-JS colors live in strings), an
+id-selector / url() gate, an allowlist, and a "definition vs usage" split that
+exempts ``--token: #fff`` token definitions by default.
+
+Every regex uses explicit ASCII classes ([0-9A-Fa-f], never \\d/\\w/\\s/\\b) and
+columns are counted in UTF-8 bytes, so the Node and Python builds emit
+byte-for-byte identical output.
+"""
+
+import re
+
+# Hex: 3/4/6/8 digits, longest-first; left guard blocks #id chaining / $interp /
+# .class / SHAs-with-#; right guard blocks 5/7-digit runs and word continuation.
+HEX = r"(?<![0-9A-Za-z_#.$-])#(?:[0-9A-Fa-f]{8}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{3})(?![0-9A-Za-z_])"
+# Functional rgb()/rgba()/hsl()/hsla() — explicit case classes (no re.I), single
+# line. The left guard (like HEX's) stops identifiers ending in rgb/hsl (brgb(), to-hsl()).
+FUNC = r"(?<![0-9A-Za-z_$@-])(?:[Rr][Gg][Bb][Aa]?|[Hh][Ss][Ll][Aa]?)\([^)\n]*\)"
+COLOR_RE = re.compile(HEX + "|" + FUNC)
+
+_DECL_RE = re.compile(r"([-_$@A-Za-z0-9]+)[ \t]*:[ \t]*[^:]*$")
+_BRACE_RE = re.compile(r"[ \t]*\{")
+_COMMA_RE = re.compile(r"[ \t]*,")
+_URL_RE = re.compile(r"url\([ \t]*['\"]?$")
+
+
+def comment_styles(ext):
+    e = str(ext).lower()
+    js = e in ("js", "jsx", "ts", "tsx", "mjs", "cjs")
+    css_pre = e in ("scss", "sass", "less")
+    css = e == "css"
+    html = e in ("html", "htm", "vue", "svelte", "astro")
+    return {
+        "strings": js or css_pre or css,
+        "template": js,
+        "line": js or css_pre,
+        "block": js or css_pre or css or html,
+        "html": html,
+    }
+
+
+def strip_comments(text, ext):
+    """Replace comment characters with spaces (newlines preserved) so the color
+    regex never matches inside a comment, keeping string contents intact and all
+    positions 1:1. Iterates by code point (== Node Array.from) for byte-stable
+    columns even with astral chars inside comments."""
+    st = comment_styles(ext)
+    chars = list(text)
+    n = len(chars)
+    out = []
+    state = "normal"
+    delim = ""
+    i = 0
+
+    def at(k):
+        return chars[k] if k < n else ""
+
+    def blank(c):
+        return "\n" if c == "\n" else " "
+
+    while i < n:
+        c = chars[i]
+        c2 = at(i + 1)
+        if state == "normal":
+            if st["strings"] and (c == "'" or c == '"' or (st["template"] and c == "`")):
+                state = "str"; delim = c; out.append(c); i += 1; continue
+            if st["line"] and c == "/" and c2 == "/":
+                state = "line"; out.append(" "); out.append(" "); i += 2; continue
+            if st["block"] and c == "/" and c2 == "*":
+                state = "block"; out.append(" "); out.append(" "); i += 2; continue
+            if st["html"] and c == "<" and c2 == "!" and at(i + 2) == "-" and at(i + 3) == "-":
+                state = "html"; out.extend([" ", " ", " ", " "]); i += 4; continue
+            out.append(c); i += 1; continue
+        if state == "str":
+            if c == "\\":
+                out.append(c)
+                if i + 1 < n:
+                    out.append(chars[i + 1])
+                i += 2; continue
+            if c == delim:
+                state = "normal"; out.append(c); i += 1; continue
+            out.append(c); i += 1; continue
+        if state == "line":
+            if c == "\n":
+                state = "normal"; out.append("\n"); i += 1; continue
+            out.append(blank(c)); i += 1; continue
+        if state == "block":
+            if c == "*" and c2 == "/":
+                state = "normal"; out.append(" "); out.append(" "); i += 2; continue
+            out.append(blank(c)); i += 1; continue
+        if state == "html":
+            if c == "-" and c2 == "-" and at(i + 2) == ">":
+                state = "normal"; out.extend([" ", " ", " "]); i += 3; continue
+            out.append(blank(c)); i += 1; continue
+    return "".join(out)
+
+
+def to_lines(text):
+    t = text
+    if t and t[0] == "":
+        t = t[1:]
+    t = t.replace("\r\n", "\n").replace("\r", "\n")
+    return t.split("\n")
+
+
+def byte_len(s):
+    return len(s.encode("utf-8"))
+
+
+def category_of(literal):
+    if literal[0] == "#":
+        return "hex" + str(len(literal) - 1)
+    return re.match(r"[A-Za-z]+", literal).group(0).lower()
+
+
+def normalize_color(lit):
+    s = lit.lower()
+    if s[0] == "#":
+        h = s[1:]
+        if len(h) in (3, 4):
+            return "#" + "".join(ch * 2 for ch in h)
+        return s
+    return re.sub(r"[ \t]", "", s)
+
+
+def property_and_definition(pre):
+    frag = re.split(r"[;{]", pre)[-1]
+    m = _DECL_RE.search(frag)
+    if not m:
+        return (None, False)
+    prop = m.group(1)
+    is_def = prop.startswith("--") or prop.startswith("$") or prop.startswith("@")
+    return (prop, is_def)
+
+
+def is_structural_hex(pre, post):
+    # Followed by `{` => id-selector (a color value never is). Handles
+    # `#fff {`, `input:focus #fff {`, minified `}#b{`.
+    if _BRACE_RE.match(post):
+        return True
+    # Followed by `,` => selector list OR value list; a selector only if its own
+    # fragment (after the last , { ;) has no `:` value separator.
+    if _COMMA_RE.match(post) and re.split(r"[,{;]", pre)[-1].find(":") == -1:
+        return True
+    if _URL_RE.search(pre):
+        return True
+    return False
+
+
+def scan_text(text, file, ext, opts):
+    allow = opts.get("allow") or set()
+    strict = bool(opts.get("strict"))
+    lines = to_lines(strip_comments(text, ext))
+    findings = []
+    for li, line in enumerate(lines):
+        for m in COLOR_RE.finditer(line):
+            literal = m.group(0)
+            start = m.start()
+            pre = line[:start]
+            post = line[start + len(literal):]
+            if literal[0] == "#" and is_structural_hex(pre, post):
+                continue
+            if normalize_color(literal) in allow:
+                continue
+            prop, is_def = property_and_definition(pre)
+            if is_def and not strict:
+                continue
+            findings.append({
+                "file": file, "line": li + 1, "column": byte_len(pre) + 1,
+                "literal": literal, "category": category_of(literal),
+                "property": prop, "isDefinition": is_def,
+            })
+    return findings
+
+
+def sort_findings(findings):
+    return sorted(findings, key=lambda f: (f["file"].encode("utf-8"), f["line"], f["column"]))
+
+
+def build_allow(items):
+    s = set()
+    for item in items or []:
+        t = item.strip()
+        if t:
+            s.add(normalize_color(t))
+    return s
+
+
+def split_color_list(s):
+    """Split a comma list, but NOT on commas inside rgb()/hsl() parens."""
+    out = []
+    cur = ""
+    depth = 0
+    for ch in str(s):
+        if ch == "(":
+            depth += 1
+            cur += ch
+        elif ch == ")":
+            if depth > 0:
+                depth -= 1
+            cur += ch
+        elif ch == "," and depth == 0:
+            out.append(cur)
+            cur = ""
+        else:
+            cur += ch
+    out.append(cur)
+    return out
+
+
+def summarize(findings, files_scanned):
+    files = {f["file"] for f in findings}
+    return {"filesScanned": files_scanned, "filesWithFindings": len(files), "findingCount": len(findings)}
+
+
+def to_json(findings, summary):
+    return {
+        "version": 1,
+        "summary": summary,
+        "findings": [{
+            "file": f["file"], "line": f["line"], "column": f["column"], "literal": f["literal"],
+            "category": f["category"], "property": f["property"], "isDefinition": f["isDefinition"],
+        } for f in findings],
+    }
+
+
+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 format_report(findings, summary, paint=None, opts=None):
+    p = paint or PLAIN
+    quiet = bool(opts and opts.get("quiet"))
+    if not findings:
+        n = summary["filesScanned"]
+        return p["green"]("✓ no hardcoded colors found") + f" ({n} file{'' if n == 1 else 's'} scanned)"
+    lines = []
+    if not quiet:
+        current = None
+        for f in findings:
+            if f["file"] != current:
+                if current is not None:
+                    lines.append("")
+                current = f["file"]
+                cnt = sum(1 for x in findings if x["file"] == f["file"])
+                lines.append(p["bold"](f["file"]) + p["dim"](f"  ({cnt})"))
+            loc = p["dim"](f"{f['line']}:{f['column']}")
+            lit = p["yellow"](f["literal"])
+            tag = p["cyan"](f"[{f['category']}]")
+            prop = p["dim"](f"  {f['property']}") if f["property"] else ""
+            lines.append(f"  {loc}  {lit}  {tag}{prop}")
+        lines.append("")
+    fc = summary["findingCount"]
+    ff = summary["filesWithFindings"]
+    clean = summary["filesScanned"] - ff
+    lines.append(
+        p["red"](f"✖ {fc} hardcoded color{'' if fc == 1 else 's'} in {ff} file{'' if ff == 1 else 's'}")
+        + p["dim"](f" ({clean} file{'' if clean == 1 else 's'} clean)"))
+    return "\n".join(lines)

hexsweep/walk.py

@@ -0,0 +1,73 @@
+"""hexsweep IO — directory walking and file reading. No scanning logic.
+
+Both builds must discover the SAME set of files (findings are sorted by path
+afterwards, so visit order doesn't affect output — but the file SET must match):
+identical ignore dirs, identical extension filter, identical symlink policy
+(never follow), and identical "skip non-UTF-8 / binary" policy.
+"""
+
+import os
+import stat as _stat
+
+IGNORE_DIRS = {
+    "node_modules", ".git", ".svn", ".hg", "dist", "build", "out",
+    "coverage", ".next", ".nuxt", "vendor", ".cache",
+}
+
+DEFAULT_EXTS = [
+    "css", "scss", "sass", "less", "vue", "svelte",
+    "jsx", "tsx", "js", "ts", "html", "htm", "astro",
+]
+
+
+def to_posix(p):
+    s = p.replace(os.sep, "/")
+    return s[2:] if s.startswith("./") else s  # normalize `.`-root like Node path.join does
+
+
+def collect_files(roots, exts, exclude_dirs):
+    ext_set = {e.lower() for e in exts}
+    ignore = set(IGNORE_DIRS) | set(exclude_dirs or [])
+    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  # never follow symlinks during recursion
+        if _stat.S_ISDIR(st.st_mode):
+            if not is_root and os.path.basename(p) in ignore:
+                return
+            try:
+                entries = os.listdir(p)
+            except OSError:
+                return
+            entries.sort(key=lambda s: s.encode("utf-8"))
+            for e in entries:
+                visit(os.path.join(p, e), False)
+        elif _stat.S_ISREG(st.st_mode):
+            ext = os.path.splitext(p)[1][1:].lower()
+            if ext in ext_set:
+                out.append(p)
+
+    for r in roots:
+        visit(r, True)
+    return out
+
+
+def read_file_text(p):
+    """Read a file as UTF-8 text, or None if binary / not valid UTF-8 (skipped
+    identically to the Node build, which detects invalid bytes by re-encoding)."""
+    try:
+        with open(p, "rb") as fh:
+            buf = fh.read()
+    except OSError:
+        return None
+    if b"\x00" in buf:
+        return None
+    try:
+        return buf.decode("utf-8")
+    except UnicodeDecodeError:
+        return None

hexsweep-0.1.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: hexsweep
+Version: 0.1.0
+Summary: Find hardcoded colors that should be design tokens — the raw #hex / rgb() that escaped your token migration. Comment- and definition-aware, zero dependencies.
+Author: yyfjj
+License: MIT
+Project-URL: Homepage, https://github.com/jjdoor/hexsweep-py
+Project-URL: Repository, https://github.com/jjdoor/hexsweep-py
+Project-URL: Issues, https://github.com/jjdoor/hexsweep-py/issues
+Keywords: hex,color,lint,linter,css,design-tokens,design-system,cli,frontend
+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
+
+# hexsweep
+
+**Find the hardcoded colors that should be design tokens.** After a token
+migration, components still have raw `background: #3f82f0` buried in them instead
+of `var(--primary-blue)` — and you don't find out until dark mode or a rebrand
+breaks. `hexsweep` scans your source and flags every raw color literal that
+escaped, with zero config and zero dependencies.
+
+```bash
+pipx run hexsweep src/
+#   src/components/Button.tsx  (2)
+#     14:18  #3f82f0  [hex6]  background
+#     27:10  rgb(255, 0, 0)  [rgb]  color
+#
+#   ✖ 2 hardcoded colors in 1 file (23 files clean)
+```
+
+Exits non-zero when it finds colors, so it drops straight into CI. Pure standard
+library. Also on npm (`npx hexsweep`) — the two builds produce **byte-for-byte
+identical** output.
+
+## Why not grep or stylelint?
+
+`grep '#[0-9a-f]{6}'` is what people fall back to, and it's noisy: it hits
+`#header` id-selectors, `url(#gradient)` references, colors in comments, and it
+can't see `rgb()`/`hsl()`, 3/4/8-digit hex, or tell a leftover from a token
+definition.
+
+**stylelint** can do it, but needs Node + a config + postcss/custom-syntax, it
+can't see hex inside TSX/CSS-in-JS string literals, and — critically — its
+`color-no-hex` flags your `tokens.css` (the one file that's *supposed* to hold
+raw colors) exactly as loudly as a stray hex in a component. The request to
+exempt token definitions has sat unimplemented for years.
+
+`hexsweep` sits in between. It's a one-shot, zero-config scanner that is:
+
+- **comment-aware** — colors in `//`, `/* */`, `<!-- -->` are skipped (but
+  strings are kept, so it *does* catch CSS-in-JS like `` styled.div`color:#3f82f0` ``);
+- **definition-aware** — `--primary: #3f82f0`, `$brand: …`, `@brand: …` are
+  allowed by default; only *usages* are flagged (use `--strict` to flag
+  definitions too);
+- **structural** — `#fff {` id-selectors and `url(#a1b2c3)` are not colors;
+- **precise** — matches hex (3/4/6/8) + `rgb()/rgba()/hsl()/hsla()`, never a
+  5- or 7-digit run, with an `--allow` list for the colors you keep on purpose.
+
+## Usage
+
+```bash
+hexsweep                          # scan the current directory
+hexsweep src/ styles/             # scan specific paths
+hexsweep --allow "#000,#fff" src  # allowlist colors that are OK to hardcode
+hexsweep --strict                 # also flag token definitions (--x/$x/@x)
+hexsweep --ext css,scss,vue       # override the scanned extensions
+hexsweep --json                   # machine output (byte-identical both builds)
+```
+
+`node_modules`, `.git`, `dist`, `build`, `coverage` (and more) are skipped by
+default; add others with `--exclude`. The default extensions are css, scss,
+sass, less, vue, svelte, jsx, tsx, js, ts, html, htm, astro.
+
+Exit codes: `0` clean · `1` hardcoded colors found · `2` error.
+
+### In CI
+
+```yaml
+- run: pipx run hexsweep src/   # fails the build on a hardcoded color
+```
+
+The `--json` shape is sorted by `(file, line, column)` so it's deterministic
+regardless of filesystem order:
+
+```json
+{
+  "version": 1,
+  "summary": { "filesScanned": 24, "filesWithFindings": 1, "findingCount": 2 },
+  "findings": [
+    { "file": "src/components/Button.tsx", "line": 14, "column": 18,
+      "literal": "#3f82f0", "category": "hex6", "property": "background", "isDefinition": false }
+  ]
+}
+```
+
+## How it works
+
+It's a line scanner, not a CSS/JS parser — that's what keeps it zero-dependency
+and lets the Node and Python builds stay byte-identical. It blanks comment spans
+(keeping string contents and every column position intact), then matches color
+literals with explicit-ASCII regexes, and applies the id-selector / url() /
+definition / allowlist gates. Columns are counted in UTF-8 bytes and files are
+visited in a fixed byte-sorted order, so output never depends on the OS or
+filesystem.
+
+## Scope
+
+MVP matches `#hex` and `rgb()/hsl()` functional notation. Named colors (`red`),
+modern `oklch()/lab()`, autofix, and a config file are intentionally left out —
+the goal is a high-signal, zero-config CI gate, not a parser.
+
+## Install
+
+```bash
+pip install hexsweep  # or pipx run hexsweep
+npm i -g hexsweep     # Node build, identical behaviour
+```
+
+Python ≥ 3.8 or Node ≥ 18. No dependencies.
+
+## License
+
+MIT

hexsweep-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+hexsweep/__init__.py,sha256=lmkLUtnktXXbR9m9sY6Bwwic-OXZgN_Gokml3LcAFME,113
+hexsweep/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
+hexsweep/cli.py,sha256=VMY1NRK0cNAYZv69-yZfYCQA8zbtxESaza9rBmEl0hI,4977
+hexsweep/core.py,sha256=3is4cTuSsmU16RDxBn6P_JXxWTnhpzgztw96KGsEwrQ,9222
+hexsweep/walk.py,sha256=-pZb-_XWkSOG1urW6rMDzahxsMT3r3D9kJYEE3TfaYM,2249
+hexsweep-0.1.0.dist-info/licenses/LICENSE,sha256=0HXg0heWs3-MqZ68PtVe-tGn7y_P-E2_ySy9-JgTH2k,1078
+hexsweep-0.1.0.dist-info/METADATA,sha256=FyZjr_mBUvpOvqhhLbWzgeSUqMOZr3Ni2R__4EODCqw,5212
+hexsweep-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+hexsweep-0.1.0.dist-info/entry_points.txt,sha256=HOScmJ_6BHGIXoHksYmvxdXROhGgYrU9SarktyLs1iw,47
+hexsweep-0.1.0.dist-info/top_level.txt,sha256=2nzto8z1l4sdw7RkvPz_yvcbDiC8E-UPFQF_lMYnXPM,9
+hexsweep-0.1.0.dist-info/RECORD,,

hexsweep-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hexsweep-0.1.0.dist-info/entry_points.txt

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

hexsweep-0.1.0.dist-info/licenses/LICENSE

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

hexsweep-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hexsweep