code-normalizer-pro 3.0.1__tar.gz → 3.0.2__tar.gz

{code_normalizer_pro-3.0.1 → code_normalizer_pro-3.0.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026
+Copyright (c) 2026 Michael Rawls Jr.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +19,3 @@ 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.
-

code_normalizer_pro-3.0.2/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: code-normalizer-pro
+Version: 3.0.2
+Summary: Production-grade code normalization tool for encoding, newlines, and whitespace hygiene.
+License: MIT
+Project-URL: Homepage, https://github.com/MRJR0101/Code-Normalizer-Pro
+Keywords: code-quality,formatter,normalization,cli,python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# code-normalizer-pro
+
+A CLI tool that normalizes encoding, line endings, and whitespace across a codebase.
+
+## Install
+
+pip install code-normalizer-pro
+
+## Usage
+
+code-normalizer-pro . --dry-run -e .py

code_normalizer_pro-3.0.2/README.md

@@ -0,0 +1,11 @@
+# code-normalizer-pro
+
+A CLI tool that normalizes encoding, line endings, and whitespace across a codebase.
+
+## Install
+
+pip install code-normalizer-pro
+
+## Usage
+
+code-normalizer-pro . --dry-run -e .py

{code_normalizer_pro-3.0.1 → code_normalizer_pro-3.0.2}/code_normalizer_pro/__init__.py

@@ -1,5 +1,4 @@
-"""Package metadata for code-normalizer-pro."""
-
-__all__ = ["__version__"]
-__version__ = "3.0.1"
-
+"""Package metadata for code-normalizer-pro."""
+
+__all__ = ["__version__"]
+__version__ = "3.0.2"

code_normalizer_pro-3.0.2/code_normalizer_pro/cli.py

@@ -0,0 +1,26 @@
+"""Console entry point for the code-normalizer-pro installed package."""
+
+from __future__ import annotations
+
+import runpy
+import sys
+from pathlib import Path
+
+
+def _find_script() -> Path:
+    """Return the path to code_normalizer_pro.py."""
+    pkg_dir = Path(__file__).resolve().parent
+    candidate = pkg_dir / "code_normalizer_pro.py"
+    if candidate.is_file():
+        return candidate
+    raise FileNotFoundError(f"code_normalizer_pro.py not found at: {candidate}")
+
+
+def main() -> None:
+    script = _find_script()
+    sys.argv[0] = str(script)
+    runpy.run_path(str(script), run_name="__main__")
+
+
+if __name__ == "__main__":
+    main()

code_normalizer_pro-3.0.1/code_normalizer_pro/code_normalize_pro.py → code_normalizer_pro-3.0.2/code_normalizer_pro/code_normalizer_pro.py

@@ -27,6 +27,7 @@ import os
 import hashlib
 import json
 import shutil
+import tempfile
 from pathlib import Path
 from typing import Optional, Tuple, List, Dict, Set
 from dataclasses import dataclass, asdict
@@ -66,7 +67,7 @@ COMMON_ENCODINGS = [
 # Multi-language syntax checkers
 SYNTAX_CHECKERS = {
     ".py": {
-        "command": ["python", "-m", "py_compile"],
+        "command": [sys.executable, "-m", "py_compile"],
         "stdin": False,
         "file_arg": True,
     },
@@ -215,7 +216,8 @@ class CodeNormalizer:
                  use_cache: bool = True,
                  interactive: bool = False,
                  parallel: bool = False,
-                 max_workers: Optional[int] = None):
+                 max_workers: Optional[int] = None,
+                 cache_path: Optional[Path] = None):
         self.dry_run = dry_run
         self.verbose = verbose
         self.in_place = in_place
@@ -224,9 +226,30 @@ class CodeNormalizer:
         self.interactive = interactive
         self.parallel = parallel
         self.max_workers = max_workers or max(1, cpu_count() - 1)
+        self.cache_path_override = cache_path
         self.stats = ProcessStats()
         self.errors: List[Tuple[Path, str]] = []
-        self.cache = CacheManager() if use_cache else None
+        self.cache = CacheManager(cache_path) if use_cache and cache_path else None
+
+    def _resolve_cache_path(self, target: Path) -> Path:
+        """Place cache beside the project or file being processed."""
+        if self.cache_path_override:
+            return self.cache_path_override
+        base = target if target.is_dir() else target.parent
+        return base / CACHE_FILE
+
+    def _ensure_cache_manager(self, target: Path) -> None:
+        """Bind cache storage to the current processing target."""
+        if not self.use_cache:
+            return
+
+        desired_path = self._resolve_cache_path(target)
+        if self.cache is None or self.cache.cache_path != desired_path:
+            self.cache = CacheManager(desired_path)
+
+    def _should_show_progress(self) -> bool:
+        """Avoid tqdm collisions with verbose per-file output."""
+        return HAS_TQDM and not self.interactive and not self.verbose
 
     def _looks_like_utf16_text(self, data: bytes) -> bool:
         """Best-effort check for UTF-16 text before binary rejection."""
@@ -320,8 +343,8 @@ class CodeNormalizer:
 
         return text, changes
 
-    def syntax_check(self, path: Path, language: Optional[str] = None) -> Tuple[bool, str]:
-        """Run syntax check on file - multi-language support"""
+    def _run_syntax_check(self, path: Path, content: Optional[str] = None) -> Tuple[bool, str]:
+        """Run a syntax checker against a file or normalized text buffer."""
         ext = path.suffix.lower()
 
         if ext not in SYNTAX_CHECKERS:
@@ -329,10 +352,24 @@ class CodeNormalizer:
 
         checker = SYNTAX_CHECKERS[ext]
         cmd = checker['command'].copy()
+        temp_path: Optional[Path] = None
 
         try:
             if checker['file_arg']:
-                cmd.append(str(path))
+                target_path = path
+                if content is not None:
+                    with tempfile.NamedTemporaryFile(
+                        "w",
+                        encoding="utf-8",
+                        newline="\n",
+                        suffix=path.suffix,
+                        delete=False,
+                    ) as tmp:
+                        tmp.write(content)
+                        temp_path = Path(tmp.name)
+                    target_path = temp_path
+
+                cmd.append(str(target_path))
                 result = subprocess.run(
                     cmd,
                     stdout=subprocess.DEVNULL,
@@ -342,8 +379,9 @@ class CodeNormalizer:
                 )
             else:
                 # Read file and pass via stdin
-                with open(path, 'r', encoding='utf-8') as f:
-                    content = f.read()
+                if content is None:
+                    with open(path, 'r', encoding='utf-8') as f:
+                        content = f.read()
                 result = subprocess.run(
                     cmd,
                     input=content,
@@ -364,6 +402,17 @@ class CodeNormalizer:
             return False, "Timeout"
         except Exception as e:
             return False, str(e)[:100]
+        finally:
+            if temp_path and temp_path.exists():
+                temp_path.unlink(missing_ok=True)
+
+    def syntax_check(self, path: Path, language: Optional[str] = None) -> Tuple[bool, str]:
+        """Run syntax check on file - multi-language support"""
+        return self._run_syntax_check(path)
+
+    def syntax_check_text(self, path: Path, text: str) -> Tuple[bool, str]:
+        """Syntax check normalized content without writing it to the real file."""
+        return self._run_syntax_check(path, content=text)
 
     def create_backup_file(self, path: Path) -> Path:
         """Create timestamped backup"""
@@ -432,6 +481,8 @@ class CodeNormalizer:
         self.stats.total_files += 1
 
         try:
+            self._ensure_cache_manager(path)
+
             # Check cache first (incremental processing)
             if self.use_cache and self.cache and self.cache.is_cached(path):
                 if self.verbose:
@@ -449,8 +500,11 @@ class CodeNormalizer:
             # Determine output
             out_path = self.get_output_path(path, output_path)
 
-            # Check if changes needed
-            if text == normalized:
+            needs_encoding_fix = enc != "utf-8"
+            needs_content_fix = text != normalized
+
+            # Check if any normalization work is needed
+            if not needs_content_fix and not needs_encoding_fix:
                 if self.verbose:
                     print(f"⊗ SKIP {path.name} - already normalized")
                 self.stats.skipped += 1
@@ -483,6 +537,15 @@ class CodeNormalizer:
                 if changes['final_newline_added']:
                     print(f"  Final newline: added")
 
+                if check_syntax:
+                    ok, reason = self.syntax_check_text(path, normalized)
+                    status = "✓ OK" if ok else f"✗ {reason}"
+                    print(f"  Syntax: {status}")
+                    if ok:
+                        self.stats.syntax_checks_passed += 1
+                    else:
+                        self.stats.syntax_checks_failed += 1
+
                 self.stats.bytes_removed += changes['bytes_removed']
                 self.stats.processed += 1
                 return True
@@ -545,6 +608,8 @@ class CodeNormalizer:
     def walk_and_process(self, root: Path, exts: List[str],
                         check_syntax: bool = False) -> None:
         """Process all files in directory tree"""
+        self._ensure_cache_manager(root)
+
         # Collect files
         files = []
         for ext in exts:
@@ -592,7 +657,10 @@ class CodeNormalizer:
 
         # Confirmation
         if not self.dry_run and self.in_place and not self.interactive:
-            response = input(f"\n⚠️  In-place editing will modify {len(files_to_process)} files. Continue? (y/N): ")
+            response = input(
+                f"\n⚠️  In-place editing will scan {len(files_to_process)} file(s) "
+                "and modify only files that need changes. Continue? (y/N): "
+            )
             if response.lower() != 'y':
                 print("Cancelled")
                 return
@@ -610,7 +678,7 @@ class CodeNormalizer:
 
     def _process_sequential(self, files: List[Path], check_syntax: bool):
         """Process files sequentially"""
-        iterator = tqdm(files, desc="Processing") if HAS_TQDM and not self.interactive else files
+        iterator = tqdm(files, desc="Processing") if self._should_show_progress() else files
 
         for file_path in iterator:
             self.process_file(file_path, check_syntax=check_syntax)
@@ -635,7 +703,7 @@ class CodeNormalizer:
 
             # Progress tracking
             iterator = as_completed(futures)
-            if HAS_TQDM:
+            if self._should_show_progress():
                 iterator = tqdm(iterator, total=len(files), desc="Processing")
 
             # Collect results
@@ -744,7 +812,7 @@ def install_git_hook(hook_type: str = "pre-commit") -> bool:
 
     # Create hook script
     hook_script = f"""#!/usr/bin/env python3
-# Auto-generated by code_normalize_pro.py
+# Auto-generated by code_normalizer_pro.py
 import subprocess
 import sys
 from pathlib import Path
@@ -790,7 +858,7 @@ def main():
         print("\\n⚠️  Some files need normalization:")
         for file_path in needs_normalization:
             print(f" - {{file_path}}")
-        print("\\nRun: python src/code_normalize_pro.py <file> --in-place")
+        print("\\nRun: uv run code-normalizer-pro <file> --in-place")
         print("Or add --no-verify to skip this check")
         sys.exit(1)
 
@@ -814,27 +882,28 @@ if __name__ == "__main__":
 
 def main():
     ap = argparse.ArgumentParser(
+        prog="code-normalizer-pro",
         description="Code Normalizer Pro - Production-grade normalization tool",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
   # Dry run with parallel processing
-  python code_normalize_pro.py /path/to/dir --dry-run --parallel
+  uv run code-normalizer-pro /path/to/dir --dry-run --parallel
 
   # Interactive mode (file-by-file approval)
-  python code_normalize_pro.py /path/to/dir --interactive
+  uv run code-normalizer-pro /path/to/dir --interactive
 
-  # In-place with incremental processing (uses cache)
-  python code_normalize_pro.py /path/to/dir -e .py --in-place --cache
+  # In-place normalization (cache is enabled by default)
+  uv run code-normalizer-pro /path/to/dir -e .py --in-place
 
-  # Multi-language syntax checking
-  python code_normalize_pro.py /path/to/dir -e .py -e .js -e .go --check
+  # Multi-language syntax checking on normalized output
+  uv run code-normalizer-pro /path/to/dir -e .py -e .js -e .go --check
 
   # Install git pre-commit hook
-  python code_normalize_pro.py --install-hook
+  uv run code-normalizer-pro --install-hook
 
   # Parallel processing (all cores)
-  python code_normalize_pro.py /path/to/dir --parallel --in-place
+  uv run code-normalizer-pro /path/to/dir --parallel --in-place
         """
     )
 
@@ -857,7 +926,7 @@ Examples:
     ap.add_argument(
         "--check",
         action="store_true",
-        help="Run syntax check after normalization"
+        help="Run syntax check on normalized output"
     )
     ap.add_argument(
         "--dry-run",
@@ -874,15 +943,16 @@ Examples:
         action="store_true",
         help="Don't create backups (dangerous!)"
     )
-    ap.add_argument(
+    cache_group = ap.add_mutually_exclusive_group()
+    cache_group.add_argument(
         "--cache",
         action="store_true",
-        help="Use incremental processing (skip unchanged files)"
+        help="Enable incremental processing cache (default)"
     )
-    ap.add_argument(
+    cache_group.add_argument(
         "--no-cache",
         action="store_true",
-        help="Disable cache (process all files)"
+        help="Disable incremental processing cache"
     )
     ap.add_argument(
         "--interactive",
@@ -934,11 +1004,7 @@ Examples:
         args.parallel = False
 
     # Determine cache setting
-    use_cache = True
-    if args.no_cache:
-        use_cache = False
-    elif args.cache:
-        use_cache = True
+    use_cache = not args.no_cache
 
     # Create normalizer
     normalizer = CodeNormalizer(
@@ -949,7 +1015,8 @@ Examples:
         use_cache=use_cache,
         interactive=args.interactive,
         parallel=args.parallel,
-        max_workers=args.workers
+        max_workers=args.workers,
+        cache_path=(args.path / CACHE_FILE) if args.path and args.path.is_dir() else (args.path.parent / CACHE_FILE)
     )
 
     print("="*70)

code_normalizer_pro-3.0.2/code_normalizer_pro.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: code-normalizer-pro
+Version: 3.0.2
+Summary: Production-grade code normalization tool for encoding, newlines, and whitespace hygiene.
+License: MIT
+Project-URL: Homepage, https://github.com/MRJR0101/Code-Normalizer-Pro
+Keywords: code-quality,formatter,normalization,cli,python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# code-normalizer-pro
+
+A CLI tool that normalizes encoding, line endings, and whitespace across a codebase.
+
+## Install
+
+pip install code-normalizer-pro
+
+## Usage
+
+code-normalizer-pro . --dry-run -e .py

{code_normalizer_pro-3.0.1 → code_normalizer_pro-3.0.2}/code_normalizer_pro.egg-info/SOURCES.txt

@@ -1,18 +1,13 @@
 LICENSE
 README.md
-main.py
 pyproject.toml
 code_normalizer_pro/__init__.py
 code_normalizer_pro/cli.py
-code_normalizer_pro/code_normalize_pro.py
+code_normalizer_pro/code_normalizer_pro.py
 code_normalizer_pro.egg-info/PKG-INFO
 code_normalizer_pro.egg-info/SOURCES.txt
 code_normalizer_pro.egg-info/dependency_links.txt
 code_normalizer_pro.egg-info/entry_points.txt
 code_normalizer_pro.egg-info/requires.txt
 code_normalizer_pro.egg-info/top_level.txt
-tests/test_code_normalize_pro.py
-tests/test_feedback_prioritizer.py
-tests/test_launch_metrics.py
-tests/test_release_prep.py
-tests/test_sales_pipeline_metrics.py
+tests/test_code_normalize_pro.py

code_normalizer_pro-3.0.2/code_normalizer_pro.egg-info/requires.txt

@@ -0,0 +1 @@
+tqdm

code_normalizer_pro-3.0.2/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "code-normalizer-pro"
+version = "3.0.2"
+description = "Production-grade code normalization tool for encoding, newlines, and whitespace hygiene."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = ["tqdm"]
+keywords = ["code-quality", "formatter", "normalization", "cli", "python"]
+
+[project.urls]
+Homepage = "https://github.com/MRJR0101/Code-Normalizer-Pro"
+
+[project.scripts]
+code-normalizer-pro = "code_normalizer_pro.cli:main"

{code_normalizer_pro-3.0.1 → code_normalizer_pro-3.0.2}/tests/test_code_normalize_pro.py

@@ -6,11 +6,7 @@ from pathlib import Path
 
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
-SRC_DIR = REPO_ROOT / "src"
-if str(SRC_DIR) not in sys.path:
-    sys.path.insert(0, str(SRC_DIR))
-
-import code_normalize_pro as cnp
+from code_normalizer_pro import code_normalizer_pro as cnp
 
 
 def test_guess_and_read_accepts_utf16_text(tmp_path: Path) -> None:
@@ -24,6 +20,38 @@ def test_guess_and_read_accepts_utf16_text(tmp_path: Path) -> None:
     assert "print('hi')" in text
 
 
+def test_in_place_rewrites_clean_utf16_to_utf8(tmp_path: Path) -> None:
+    sample = tmp_path / "utf16_clean.py"
+    sample.write_text("print('hi')\n", encoding="utf-16")
+
+    normalizer = cnp.CodeNormalizer(
+        in_place=True,
+        create_backup=False,
+        use_cache=False,
+    )
+
+    assert normalizer.process_file(sample) is True
+    assert sample.read_text(encoding="utf-8") == "print('hi')\n"
+    assert not sample.read_bytes().startswith((b"\xff\xfe", b"\xfe\xff"))
+    assert normalizer.stats.processed == 1
+    assert normalizer.stats.encoding_changes == 1
+
+
+def test_dry_run_check_validates_normalized_output(tmp_path: Path, capsys) -> None:
+    sample = tmp_path / "needs_fix.py"
+    sample.write_bytes(b"print('hi')  \r\n")
+
+    normalizer = cnp.CodeNormalizer(dry_run=True, use_cache=False)
+
+    assert normalizer.process_file(sample, check_syntax=True) is True
+    captured = capsys.readouterr()
+
+    assert "Would normalize" in captured.out
+    assert "Syntax: \u2713 OK" in captured.out
+    assert normalizer.stats.processed == 1
+    assert normalizer.stats.syntax_checks_passed == 1
+
+
 def test_guess_and_read_rejects_binary_with_nuls(tmp_path: Path) -> None:
     sample = tmp_path / "blob.bin"
     sample.write_bytes(b"\x89PNG\x00\x01\x02\x03\x04\x00\x00\xff")
@@ -53,7 +81,7 @@ def test_install_git_hook_uses_current_python_and_checks_failures(tmp_path: Path
     assert "for file_path in files" in hook_text
     assert 'file_path, "--dry-run"' in hook_text
     assert "result.returncode != 0" in hook_text
-    assert "src/code_normalize_pro.py" in hook_text
+    assert "code_normalizer_pro.py" in hook_text
 
 
 def test_install_hook_cli_exits_nonzero_outside_git_repo(tmp_path: Path) -> None:
@@ -116,3 +144,19 @@ def test_parallel_cache_hits_are_persisted(tmp_path: Path) -> None:
     assert second.returncode == 0, second.stderr
     assert "All discovered files were unchanged and skipped by cache." in second.stdout
     assert "⊙ Cached hits: 2" in second.stdout
+
+
+def test_cache_file_scoped_to_target_directory(tmp_path: Path, monkeypatch) -> None:
+    sample_dir = tmp_path / "samples"
+    sample_dir.mkdir()
+    (sample_dir / "a.py").write_text("print('a')  \n", encoding="utf-8")
+
+    elsewhere = tmp_path / "elsewhere"
+    elsewhere.mkdir()
+    monkeypatch.chdir(elsewhere)
+
+    normalizer = cnp.CodeNormalizer(use_cache=True)
+    normalizer.walk_and_process(sample_dir, [".py"])
+
+    assert (sample_dir / cnp.CACHE_FILE).exists()
+    assert not (elsewhere / cnp.CACHE_FILE).exists()