code-normalizer-pro 3.0.1__py3-none-any.whl

code_normalizer_pro/__init__.py

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

code_normalizer_pro/cli.py

@@ -0,0 +1,42 @@
+"""Console entry point for the code-normalizer-pro installed package.
+
+Uses runpy so the core script (src/code_normalize_pro.py) does not need
+to be a proper importable module. Works correctly under editable installs
+(pip install -e .). Before building a wheel for PyPI distribution, copy
+src/code_normalize_pro.py into this package directory and update
+_find_script() to look for it there.
+"""
+
+from __future__ import annotations
+
+import runpy
+import sys
+from pathlib import Path
+
+
+def _find_script() -> Path:
+    """Return the path to code_normalize_pro.py.
+
+    Search order:
+    1. src/ next to package root -- editable / dev install
+    2. Inside this package dir -- future bundled layout
+    """
+    pkg_dir = Path(__file__).resolve().parent        # code_normalizer_pro/
+    root = pkg_dir.parent
+    candidates = [
+        root / "src" / "code_normalize_pro.py",     # editable install
+        pkg_dir / "code_normalize_pro.py",          # future bundled
+    ]
+    for p in candidates:
+        if p.is_file():
+            return p
+    checked = ", ".join(str(c) for c in candidates)
+    raise FileNotFoundError(
+        f"code_normalize_pro.py not found. Checked: {checked}"
+    )
+
+
+def main() -> None:
+    script = _find_script()
+    sys.argv[0] = str(script)
+    runpy.run_path(str(script), run_name="__main__")

code_normalizer_pro/code_normalize_pro.py

@@ -0,0 +1,989 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Code Normalizer Pro - Production-Grade Code Normalization Tool
+================================================================
+
+High-Impact Features:
+- Parallel Processing (multi-core performance)
+- Pre-Commit Hook Generation
+- Incremental Processing (hash-based caching)
+- Multi-Language Syntax Checking
+- Interactive Mode (file-by-file approval)
+
+Plus all v2.0 features:
+- Dry-run mode, In-place editing, Automatic backups
+- Progress tracking, Detailed statistics, Error handling
+
+Author: MR
+Date: 2026-02-09
+Version: 3.0 Pro
+"""
+
+import argparse
+import subprocess
+import sys
+import os
+import hashlib
+import json
+import shutil
+from pathlib import Path
+from typing import Optional, Tuple, List, Dict, Set
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from multiprocessing import cpu_count
+
+# Fix Windows console encoding
+if sys.platform == 'win32':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except AttributeError:
+        import io
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+os.environ['PYTHONIOENCODING'] = 'utf-8'
+
+# Optional dependencies
+try:
+    from tqdm import tqdm
+    HAS_TQDM = True
+except ImportError:
+    HAS_TQDM = False
+
+COMMON_ENCODINGS = [
+    "utf-8",
+    "utf-8-sig",
+    "utf-16",
+    "utf-16-le",
+    "utf-16-be",
+    "windows-1252",
+    "latin-1",
+    "iso-8859-1",
+]
+
+# Multi-language syntax checkers
+SYNTAX_CHECKERS = {
+    ".py": {
+        "command": ["python", "-m", "py_compile"],
+        "stdin": False,
+        "file_arg": True,
+    },
+    ".js": {
+        "command": ["node", "--check"],
+        "stdin": False,
+        "file_arg": True,
+    },
+    ".ts": {
+        "command": ["tsc", "--noEmit"],
+        "stdin": False,
+        "file_arg": True,
+    },
+    ".go": {
+        "command": ["gofmt", "-e"],
+        "stdin": True,
+        "file_arg": False,
+    },
+    ".rs": {
+        "command": ["rustc", "--crate-type", "lib", "-"],
+        "stdin": True,
+        "file_arg": False,
+    },
+    ".c": {
+        "command": ["gcc", "-fsyntax-only", "-x", "c"],
+        "stdin": False,
+        "file_arg": True,
+    },
+    ".cpp": {
+        "command": ["g++", "-fsyntax-only", "-x", "c++"],
+        "stdin": False,
+        "file_arg": True,
+    },
+    ".java": {
+        "command": ["javac", "-Xstdout"],
+        "stdin": False,
+        "file_arg": True,
+    },
+}
+
+CACHE_FILE = ".normalize-cache.json"
+
+
+@dataclass
+class FileCache:
+    """Cache entry for a file"""
+    path: str
+    hash: str
+    last_normalized: str
+    size: int
+
+
+@dataclass
+class ProcessStats:
+    """Statistics for processing session"""
+    total_files: int = 0
+    processed: int = 0
+    skipped: int = 0
+    cached: int = 0
+    errors: int = 0
+    encoding_changes: int = 0
+    newline_fixes: int = 0
+    whitespace_fixes: int = 0
+    syntax_checks_passed: int = 0
+    syntax_checks_failed: int = 0
+    bytes_removed: int = 0
+
+
+class CacheManager:
+    """Manages file hash cache for incremental processing"""
+
+    def __init__(self, cache_path: Optional[Path] = None):
+        self.cache_path = cache_path or Path(CACHE_FILE)
+        self.cache: Dict[str, FileCache] = {}
+        self.load()
+
+    def load(self):
+        """Load cache from disk"""
+        if self.cache_path.exists():
+            try:
+                with open(self.cache_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self.cache = {
+                        k: FileCache(**v) for k, v in data.items()
+                    }
+            except Exception as e:
+                print(f"Warning: Could not load cache: {e}")
+                self.cache = {}
+
+    def save(self):
+        """Save cache to disk"""
+        try:
+            with open(self.cache_path, 'w', encoding='utf-8') as f:
+                data = {k: asdict(v) for k, v in self.cache.items()}
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Could not save cache: {e}")
+
+    def get_file_hash(self, path: Path) -> str:
+        """Calculate SHA256 hash of file"""
+        sha256 = hashlib.sha256()
+        with open(path, 'rb') as f:
+            for chunk in iter(lambda: f.read(8192), b''):
+                sha256.update(chunk)
+        return sha256.hexdigest()
+
+    def is_cached(self, path: Path) -> bool:
+        """Check if file is in cache and unchanged"""
+        path_str = str(path)
+        if path_str not in self.cache:
+            return False
+
+        cached = self.cache[path_str]
+
+        # Check if file still exists
+        if not path.exists():
+            return False
+
+        # Check size first (fast check)
+        if path.stat().st_size != cached.size:
+            return False
+
+        # Check hash (slower but accurate)
+        current_hash = self.get_file_hash(path)
+        return current_hash == cached.hash
+
+    def update(self, path: Path):
+        """Update cache entry for file"""
+        path_str = str(path)
+        self.cache[path_str] = FileCache(
+            path=path_str,
+            hash=self.get_file_hash(path),
+            last_normalized=datetime.now().isoformat(),
+            size=path.stat().st_size
+        )
+
+
+class CodeNormalizer:
+    """Production-grade code normalizer with advanced features"""
+
+    def __init__(self,
+                 dry_run: bool = False,
+                 verbose: bool = False,
+                 in_place: bool = False,
+                 create_backup: bool = True,
+                 use_cache: bool = True,
+                 interactive: bool = False,
+                 parallel: bool = False,
+                 max_workers: Optional[int] = None):
+        self.dry_run = dry_run
+        self.verbose = verbose
+        self.in_place = in_place
+        self.create_backup = create_backup
+        self.use_cache = use_cache
+        self.interactive = interactive
+        self.parallel = parallel
+        self.max_workers = max_workers or max(1, cpu_count() - 1)
+        self.stats = ProcessStats()
+        self.errors: List[Tuple[Path, str]] = []
+        self.cache = CacheManager() if use_cache else None
+
+    def _looks_like_utf16_text(self, data: bytes) -> bool:
+        """Best-effort check for UTF-16 text before binary rejection."""
+        if not data:
+            return False
+
+        # BOM signatures
+        if data.startswith((b"\xff\xfe", b"\xfe\xff")):
+            return True
+
+        sample = data[:256]
+        if len(sample) < 4:
+            return False
+
+        for enc in ("utf-16-le", "utf-16-be"):
+            try:
+                decoded = sample.decode(enc)
+            except UnicodeDecodeError:
+                continue
+
+            if not decoded:
+                continue
+
+            printable = sum(1 for ch in decoded if ch.isprintable() or ch in "\r\n\t")
+            alpha = sum(1 for ch in decoded if ch.isalpha())
+            printable_ratio = printable / len(decoded)
+
+            # Require mostly printable content and at least some alphabetic text.
+            if printable_ratio >= 0.85 and alpha >= max(1, len(decoded) // 20):
+                return True
+
+        return False
+
+    def guess_and_read(self, path: Path) -> Tuple[str, str]:
+        """Detect encoding and read file"""
+        data = path.read_bytes()
+
+        if b"\x00" in data and not self._looks_like_utf16_text(data):
+            raise ValueError(f"File appears to be binary")
+
+        last_error = None
+        for enc in COMMON_ENCODINGS:
+            try:
+                text = data.decode(enc)
+                return enc, text
+            except UnicodeDecodeError as e:
+                last_error = e
+                continue
+
+        raise UnicodeError(
+            f"Could not decode with common encodings"
+        ) from last_error
+
+    def normalize_text(self, text: str) -> Tuple[str, dict]:
+        """Normalize text and track changes"""
+        changes = {
+            'newline_fixes': 0,
+            'whitespace_fixes': 0,
+            'bytes_removed': 0,
+            'final_newline_added': False
+        }
+
+        original = text
+        original_size = len(text.encode('utf-8'))
+
+        # Normalize newlines
+        if '\r\n' in text or '\r' in text:
+            text = text.replace("\r\n", "\n").replace("\r", "\n")
+            changes['newline_fixes'] = original.count('\r\n') + original.count('\r')
+
+        # Strip trailing whitespace
+        lines = text.split("\n")
+        stripped_lines = [line.rstrip() for line in lines]
+
+        whitespace_removed = sum(
+            len(orig) - len(stripped)
+            for orig, stripped in zip(lines, stripped_lines)
+        )
+        changes['whitespace_fixes'] = whitespace_removed
+
+        text = "\n".join(stripped_lines)
+
+        # Ensure final newline
+        if not text.endswith("\n"):
+            text += "\n"
+            changes['final_newline_added'] = True
+
+        # Calculate bytes removed
+        new_size = len(text.encode('utf-8'))
+        changes['bytes_removed'] = original_size - new_size
+
+        return text, changes
+
+    def syntax_check(self, path: Path, language: Optional[str] = None) -> Tuple[bool, str]:
+        """Run syntax check on file - multi-language support"""
+        ext = path.suffix.lower()
+
+        if ext not in SYNTAX_CHECKERS:
+            return True, "No checker available"
+
+        checker = SYNTAX_CHECKERS[ext]
+        cmd = checker['command'].copy()
+
+        try:
+            if checker['file_arg']:
+                cmd.append(str(path))
+                result = subprocess.run(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.PIPE,
+                    timeout=10,
+                    text=True
+                )
+            else:
+                # Read file and pass via stdin
+                with open(path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                result = subprocess.run(
+                    cmd,
+                    input=content,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.PIPE,
+                    timeout=10,
+                    text=True
+                )
+
+            if result.returncode == 0:
+                return True, "OK"
+            else:
+                return False, result.stderr.strip()[:100]
+
+        except FileNotFoundError:
+            return True, f"{checker['command'][0]} not installed"
+        except subprocess.TimeoutExpired:
+            return False, "Timeout"
+        except Exception as e:
+            return False, str(e)[:100]
+
+    def create_backup_file(self, path: Path) -> Path:
+        """Create timestamped backup"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = path.with_suffix(f".backup_{timestamp}{path.suffix}")
+        backup_path.write_bytes(path.read_bytes())
+        return backup_path
+
+    def get_output_path(self, input_path: Path, output_path: Optional[Path]) -> Path:
+        """Determine output path"""
+        if output_path:
+            return output_path
+        if self.in_place:
+            return input_path
+        return input_path.with_name(input_path.stem + "_clean" + input_path.suffix)
+
+    def show_diff(self, path: Path, original: str, normalized: str) -> bool:
+        """Show diff and get user approval (interactive mode)"""
+        print(f"\n{'='*70}")
+        print(f"File: {path}")
+        print(f"{'='*70}")
+
+        # Simple line-by-line diff
+        orig_lines = original.split('\n')
+        norm_lines = normalized.split('\n')
+
+        changes = []
+        for i, (orig, norm) in enumerate(zip(orig_lines, norm_lines), 1):
+            if orig != norm:
+                changes.append((i, orig, norm))
+
+        # Show first 10 changes
+        for line_num, orig, norm in changes[:10]:
+            print(f"\nLine {line_num}:")
+            print(f"  - {repr(orig)}")
+            print(f"  + {repr(norm)}")
+
+        if len(changes) > 10:
+            print(f"\n... and {len(changes) - 10} more changes")
+
+        print(f"\n{'='*70}")
+
+        # Get user input
+        while True:
+            choice = input("Apply changes? [y]es / [n]o / [d]iff all / [q]uit: ").lower()
+
+            if choice in ('y', 'yes'):
+                return True
+            elif choice in ('n', 'no'):
+                return False
+            elif choice in ('d', 'diff'):
+                # Show all changes
+                for line_num, orig, norm in changes:
+                    print(f"\nLine {line_num}:")
+                    print(f"  - {repr(orig)}")
+                    print(f"  + {repr(norm)}")
+            elif choice in ('q', 'quit'):
+                print("Quitting...")
+                sys.exit(0)
+            else:
+                print("Invalid choice. Please enter y, n, d, or q.")
+
+    def process_file(self, path: Path, output_path: Optional[Path] = None,
+                    check_syntax: bool = False) -> bool:
+        """Process a single file"""
+        self.stats.total_files += 1
+
+        try:
+            # Check cache first (incremental processing)
+            if self.use_cache and self.cache and self.cache.is_cached(path):
+                if self.verbose:
+                    print(f"⊙ CACHED {path.name} - unchanged since last run")
+                self.stats.cached += 1
+                self.stats.skipped += 1
+                return True
+
+            # Read and detect encoding
+            enc, text = self.guess_and_read(path)
+
+            # Normalize
+            normalized, changes = self.normalize_text(text)
+
+            # Determine output
+            out_path = self.get_output_path(path, output_path)
+
+            # Check if changes needed
+            if text == normalized:
+                if self.verbose:
+                    print(f"⊗ SKIP {path.name} - already normalized")
+                self.stats.skipped += 1
+
+                # Update cache even for unchanged files
+                if self.use_cache and self.cache:
+                    self.cache.update(path)
+
+                return True
+
+            # Interactive mode
+            if self.interactive and not self.dry_run:
+                if not self.show_diff(path, text, normalized):
+                    print(f"⊗ SKIP {path.name} - user declined")
+                    self.stats.skipped += 1
+                    return True
+
+            # Dry run mode
+            if self.dry_run:
+                print(f"[DRY RUN] Would normalize: {path}")
+                if enc != "utf-8":
+                    print(f"  Encoding: {enc} → utf-8")
+                    self.stats.encoding_changes += 1
+                if changes['newline_fixes'] > 0:
+                    print(f"  Newlines: {changes['newline_fixes']} fixes")
+                    self.stats.newline_fixes += 1
+                if changes['whitespace_fixes'] > 0:
+                    print(f"  Whitespace: {changes['whitespace_fixes']} chars removed")
+                    self.stats.whitespace_fixes += 1
+                if changes['final_newline_added']:
+                    print(f"  Final newline: added")
+
+                self.stats.bytes_removed += changes['bytes_removed']
+                self.stats.processed += 1
+                return True
+
+            # Create backup if needed
+            backup_created = None
+            if self.in_place and self.create_backup:
+                backup_created = self.create_backup_file(path)
+
+            # Write normalized version
+            out_path.write_text(normalized, encoding="utf-8", newline="\n")
+
+            # Update stats
+            self.stats.processed += 1
+            self.stats.bytes_removed += changes['bytes_removed']
+            if enc != "utf-8":
+                self.stats.encoding_changes += 1
+            if changes['newline_fixes'] > 0:
+                self.stats.newline_fixes += 1
+            if changes['whitespace_fixes'] > 0:
+                self.stats.whitespace_fixes += 1
+
+            # Report
+            if self.in_place:
+                msg = f"✓ {path.name} (in-place)"
+            else:
+                msg = f"✓ {path.name} → {out_path.name}"
+
+            if enc != "utf-8":
+                msg += f" [{enc}→utf-8]"
+
+            print(msg)
+
+            if backup_created:
+                print(f"  Backup: {backup_created.name}")
+
+            # Syntax check
+            if check_syntax:
+                ok, reason = self.syntax_check(out_path)
+                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
+
+            # Update cache
+            if self.use_cache and self.cache:
+                self.cache.update(path)
+
+            return True
+
+        except Exception as e:
+            self.stats.errors += 1
+            self.errors.append((path, str(e)))
+            print(f"✗ ERROR {path.name}: {e}")
+            return False
+
+    def walk_and_process(self, root: Path, exts: List[str],
+                        check_syntax: bool = False) -> None:
+        """Process all files in directory tree"""
+        # Collect files
+        files = []
+        for ext in exts:
+            files.extend(root.rglob(f"*{ext}"))
+
+        files = [f for f in files if f.is_file()]
+
+        if not files:
+            print(f"No files with extensions {exts} found in {root}")
+            return
+
+        files_to_process = files
+        if self.use_cache and self.cache:
+            uncached_files = []
+            cached_hits = 0
+            for file_path in files:
+                if self.cache.is_cached(file_path):
+                    cached_hits += 1
+                    self.stats.cached += 1
+                    self.stats.skipped += 1
+                    self.stats.total_files += 1
+                    if self.verbose:
+                        print(f"⊙ CACHED {file_path.name} - unchanged since last run")
+                else:
+                    uncached_files.append(file_path)
+            files_to_process = uncached_files
+
+            if cached_hits and self.verbose:
+                print(f"⊙ Cache prefilter skipped {cached_hits} unchanged file(s)")
+
+        print(f"\n📁 Found {len(files)} file(s) to process")
+        print(f"   Extensions: {', '.join(exts)}")
+        mode_desc = "DRY RUN" if self.dry_run else "IN-PLACE" if self.in_place else "CLEAN COPY"
+        if self.parallel:
+            mode_desc += f" (PARALLEL {self.max_workers} workers)"
+        if self.use_cache:
+            mode_desc += " (CACHED)"
+        if self.interactive:
+            mode_desc += " (INTERACTIVE)"
+        print(f"   Mode: {mode_desc}")
+
+        if not files_to_process:
+            print("All discovered files were unchanged and skipped by cache.")
+            return
+
+        # 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): ")
+            if response.lower() != 'y':
+                print("Cancelled")
+                return
+
+        # Process files
+
+        if self.parallel and not self.interactive:
+            self._process_parallel(files_to_process, check_syntax)
+        else:
+            self._process_sequential(files_to_process, check_syntax)
+
+        # Save cache
+        if self.use_cache and self.cache and not self.dry_run:
+            self.cache.save()
+
+    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
+
+        for file_path in iterator:
+            self.process_file(file_path, check_syntax=check_syntax)
+
+    def _process_parallel(self, files: List[Path], check_syntax: bool):
+        """Process files in parallel"""
+        print(f"\n🚀 Parallel processing with {self.max_workers} workers...\n")
+
+        with ProcessPoolExecutor(max_workers=self.max_workers) as executor:
+            # Submit all tasks
+            futures = {
+                executor.submit(
+                    process_file_worker,
+                    file_path,
+                    self.dry_run,
+                    self.in_place,
+                    self.create_backup,
+                    check_syntax
+                ): file_path
+                for file_path in files
+            }
+
+            # Progress tracking
+            iterator = as_completed(futures)
+            if HAS_TQDM:
+                iterator = tqdm(iterator, total=len(files), desc="Processing")
+
+            # Collect results
+            for future in iterator:
+                file_path = futures[future]
+                try:
+                    success, stats_update, error = future.result()
+
+                    # Update stats
+                    self.stats.total_files += 1
+                    if success:
+                        self.stats.processed += stats_update['processed']
+                        self.stats.skipped += stats_update['skipped']
+                        self.stats.encoding_changes += stats_update['encoding_changes']
+                        self.stats.newline_fixes += stats_update['newline_fixes']
+                        self.stats.whitespace_fixes += stats_update['whitespace_fixes']
+                        self.stats.bytes_removed += stats_update['bytes_removed']
+                        self.stats.syntax_checks_passed += stats_update['syntax_checks_passed']
+                        self.stats.syntax_checks_failed += stats_update['syntax_checks_failed']
+                        if self.use_cache and self.cache and not self.dry_run:
+                            self.cache.update(file_path)
+                    else:
+                        self.stats.errors += 1
+                        self.errors.append((file_path, error))
+
+                except Exception as e:
+                    self.stats.errors += 1
+                    self.errors.append((file_path, str(e)))
+
+    def print_summary(self):
+        """Print processing summary"""
+        print("\n" + "="*70)
+        print("PROCESSING SUMMARY")
+        print("="*70)
+        print(f"  Total files: {self.stats.total_files}")
+        print(f"  ✓ Processed: {self.stats.processed}")
+        print(f"  ⊗ Skipped: {self.stats.skipped}")
+        if self.use_cache:
+            print(f"  ⊙ Cached hits: {self.stats.cached}")
+        print(f"  ✗ Errors: {self.stats.errors}")
+        print()
+        print(f"  Encoding changes: {self.stats.encoding_changes}")
+        print(f"  Newline fixes: {self.stats.newline_fixes}")
+        print(f"  Whitespace fixes: {self.stats.whitespace_fixes}")
+        print(f"  Bytes removed: {self.stats.bytes_removed:,}")
+
+        if self.stats.syntax_checks_passed > 0 or self.stats.syntax_checks_failed > 0:
+            print()
+            print(f"  Syntax checks passed: {self.stats.syntax_checks_passed}")
+            print(f"  Syntax checks failed: {self.stats.syntax_checks_failed}")
+
+        if self.errors:
+            print("\n❌ ERRORS:")
+            for path, error in self.errors[:10]:
+                print(f"  {path.name}: {error}")
+            if len(self.errors) > 10:
+                print(f"  ... and {len(self.errors) - 10} more")
+
+        print("="*70)
+
+
+def process_file_worker(file_path: Path, dry_run: bool, in_place: bool,
+                       create_backup: bool, check_syntax: bool) -> Tuple[bool, dict, str]:
+    """Worker function for parallel processing"""
+    normalizer = CodeNormalizer(
+        dry_run=dry_run,
+        in_place=in_place,
+        create_backup=create_backup,
+        use_cache=False,  # Cache managed by main process
+        interactive=False,
+        parallel=False
+    )
+
+    success = normalizer.process_file(file_path, check_syntax=check_syntax)
+
+    stats_update = {
+        'processed': normalizer.stats.processed,
+        'skipped': normalizer.stats.skipped,
+        'encoding_changes': normalizer.stats.encoding_changes,
+        'newline_fixes': normalizer.stats.newline_fixes,
+        'whitespace_fixes': normalizer.stats.whitespace_fixes,
+        'bytes_removed': normalizer.stats.bytes_removed,
+        'syntax_checks_passed': normalizer.stats.syntax_checks_passed,
+        'syntax_checks_failed': normalizer.stats.syntax_checks_failed,
+    }
+
+    error = normalizer.errors[0][1] if normalizer.errors else ""
+
+    return success, stats_update, error
+
+
+def install_git_hook(hook_type: str = "pre-commit") -> bool:
+    """Install pre-commit hook for automatic normalization"""
+    git_dir = Path(".git")
+
+    if not git_dir.exists():
+        print("❌ Not a git repository")
+        return False
+
+    hooks_dir = git_dir / "hooks"
+    hooks_dir.mkdir(exist_ok=True)
+
+    hook_path = hooks_dir / hook_type
+
+    normalizer_script = Path(__file__).resolve()
+
+    # Create hook script
+    hook_script = f"""#!/usr/bin/env python3
+# Auto-generated by code_normalize_pro.py
+import subprocess
+import sys
+from pathlib import Path
+
+def main():
+    # Get staged Python files
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--name-only", "--diff-filter=ACM"],
+        capture_output=True,
+        text=True
+    )
+
+    files = [
+        f for f in result.stdout.strip().split('\\n')
+        if f.endswith('.py') and Path(f).exists()
+    ]
+
+    if not files:
+        sys.exit(0)
+
+    print(f"🔍 Checking {{len(files)}} Python file(s)...")
+
+    # Run normalizer in check mode, one file at a time. The CLI accepts a
+    # single positional path, so passing all files at once breaks argparse.
+    needs_normalization = []
+    for file_path in files:
+        result = subprocess.run(
+            [sys.executable, r"{normalizer_script}", file_path, "--dry-run"],
+            capture_output=True,
+            text=True
+        )
+
+        if result.returncode != 0:
+            print("\\n❌ Normalizer execution failed")
+            if result.stderr.strip():
+                print(result.stderr.strip())
+            sys.exit(result.returncode)
+
+        if "Would normalize:" in result.stdout:
+            needs_normalization.append(file_path)
+
+    if needs_normalization:
+        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("Or add --no-verify to skip this check")
+        sys.exit(1)
+
+    print("✅ All files are normalized")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()
+"""
+
+    # Write hook
+    hook_path.write_text(hook_script, encoding="utf-8", newline="\n")
+    hook_path.chmod(0o755)
+
+    print(f"✅ Installed {hook_type} hook at {hook_path}")
+    print(f"   Hook will check Python files before commit")
+    print(f"   Use 'git commit --no-verify' to skip check")
+
+    return True
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        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
+
+  # Interactive mode (file-by-file approval)
+  python code_normalize_pro.py /path/to/dir --interactive
+
+  # In-place with incremental processing (uses cache)
+  python code_normalize_pro.py /path/to/dir -e .py --in-place --cache
+
+  # Multi-language syntax checking
+  python code_normalize_pro.py /path/to/dir -e .py -e .js -e .go --check
+
+  # Install git pre-commit hook
+  python code_normalize_pro.py --install-hook
+
+  # Parallel processing (all cores)
+  python code_normalize_pro.py /path/to/dir --parallel --in-place
+        """
+    )
+
+    ap.add_argument(
+        "path",
+        type=Path,
+        nargs="?",
+        help="File or directory to process"
+    )
+    ap.add_argument(
+        "-e", "--ext",
+        action="append",
+        help="File extensions (e.g. -e .py -e .js)"
+    )
+    ap.add_argument(
+        "-o", "--output",
+        type=Path,
+        help="Output file (single file mode only)"
+    )
+    ap.add_argument(
+        "--check",
+        action="store_true",
+        help="Run syntax check after normalization"
+    )
+    ap.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview changes without modifying files"
+    )
+    ap.add_argument(
+        "--in-place",
+        action="store_true",
+        help="Edit files in-place"
+    )
+    ap.add_argument(
+        "--no-backup",
+        action="store_true",
+        help="Don't create backups (dangerous!)"
+    )
+    ap.add_argument(
+        "--cache",
+        action="store_true",
+        help="Use incremental processing (skip unchanged files)"
+    )
+    ap.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="Disable cache (process all files)"
+    )
+    ap.add_argument(
+        "--interactive",
+        action="store_true",
+        help="Interactive mode (approve each file)"
+    )
+    ap.add_argument(
+        "--parallel",
+        action="store_true",
+        help="Parallel processing (multi-core)"
+    )
+    ap.add_argument(
+        "--workers",
+        type=int,
+        help=f"Number of parallel workers (default: {max(1, cpu_count() - 1)})"
+    )
+    ap.add_argument(
+        "--install-hook",
+        action="store_true",
+        help="Install git pre-commit hook"
+    )
+    ap.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Verbose output"
+    )
+
+    args = ap.parse_args()
+
+    # Install hook mode
+    if args.install_hook:
+        success = install_git_hook()
+        sys.exit(0 if success else 1)
+
+    # Validate
+    if not args.path:
+        ap.print_help()
+        sys.exit(1)
+
+    if args.output and args.path.is_dir():
+        print("Error: --output only works with single file")
+        sys.exit(1)
+
+    if args.no_backup and not args.in_place:
+        print("Warning: --no-backup has no effect without --in-place")
+
+    if args.interactive and args.parallel:
+        print("Warning: --interactive disables --parallel")
+        args.parallel = False
+
+    # Determine cache setting
+    use_cache = True
+    if args.no_cache:
+        use_cache = False
+    elif args.cache:
+        use_cache = True
+
+    # Create normalizer
+    normalizer = CodeNormalizer(
+        dry_run=args.dry_run,
+        verbose=args.verbose,
+        in_place=args.in_place,
+        create_backup=not args.no_backup,
+        use_cache=use_cache,
+        interactive=args.interactive,
+        parallel=args.parallel,
+        max_workers=args.workers
+    )
+
+    print("="*70)
+    print("CODE NORMALIZER PRO v3.0")
+    print("="*70)
+
+    # Process
+    try:
+        if args.path.is_dir():
+            exts = args.ext or [".py"]
+            normalizer.walk_and_process(args.path, exts, check_syntax=args.check)
+        else:
+            if not args.path.exists():
+                print(f"Error: File not found: {args.path}")
+                sys.exit(1)
+
+            normalizer.process_file(args.path, args.output, check_syntax=args.check)
+
+        # Summary
+        normalizer.print_summary()
+
+        # Exit code
+        sys.exit(0 if normalizer.stats.errors == 0 else 1)
+
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Interrupted by user")
+        normalizer.print_summary()
+        sys.exit(130)
+    except Exception as e:
+        print(f"\n❌ Fatal error: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

code_normalizer_pro-3.0.1.dist-info/METADATA

@@ -0,0 +1,304 @@
+Metadata-Version: 2.4
+Name: code-normalizer-pro
+Version: 3.0.1
+Summary: Production-grade code normalization tool for encoding, newlines, and whitespace hygiene.
+Author: MR
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/MRJR0101/code-normalizer-pro
+Project-URL: Documentation, https://github.com/MRJR0101/code-normalizer-pro/blob/main/README.md
+Project-URL: Issues, https://github.com/MRJR0101/code-normalizer-pro/issues
+Keywords: code-quality,formatter,normalization,cli,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tqdm
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# CODE - Code Normalization Tool
+
+**Python CLI that cleans up source code encoding, line endings, and whitespace
+across entire codebases -- with parallel processing, SHA256 caching, and pre-commit hook support.**
+
+- Location: `C:\Dev\PROJECTS\CODE`
+- Status: v3.0 code complete. Package stub ready. No pyproject.toml = blocked from PyPI.
+- Updated: 2026-03-10
+
+---
+
+## What It Does
+
+Run it against any directory and it will:
+
+1. Detect and convert file encoding to UTF-8
+   (handles utf-8, utf-8-sig, utf-16, utf-16-le, utf-16-be, windows-1252, latin-1, iso-8859-1)
+2. Fix line endings -- CRLF to LF
+3. Strip trailing whitespace from every line
+4. Ensure a single newline at end of file
+5. Optionally validate syntax for Python, JS, TS, Go, Rust, C, C++, Java
+
+Files already clean are skipped. SHA256 caching means repeat runs on unchanged files
+are near-instant. Multi-core parallel mode handles large codebases at 80-200 files/sec.
+
+---
+
+## Quick Start
+
+```powershell
+Set-Location C:\Dev\PROJECTS\CODE
+
+# See what would change without touching anything
+python main.py C:\path\to\project --dry-run
+
+# Normalize everything in-place using all CPU cores
+python main.py C:\path\to\project --parallel --in-place
+
+# Normalize only Python and JavaScript files
+python main.py C:\path\to\project -e .py -e .js --in-place
+
+# Review and approve each file before it's written
+python main.py C:\path\to\project --interactive
+
+# Run syntax validation after normalizing
+python main.py C:\path\to\project --in-place --check
+
+# Install a pre-commit hook into a git repo
+cd C:\your-repo
+python C:\Dev\PROJECTS\CODE\main.py --install-hook
+```
+
+`main.py` at root is a thin wrapper that delegates to `src/code_normalize_pro.py`.
+Call either one -- same result.
+
+---
+
+## Pre-Commit Hook
+
+Checks only staged files before each commit. Blocks commit if any need normalization
+and prints the fix command.
+
+```powershell
+# One-time install per repo
+cd C:\your-repo
+python C:\Dev\PROJECTS\CODE\main.py --install-hook
+
+# Commit as normal -- hook fires automatically
+git commit -m "your message"
+
+# Skip hook for one commit
+git commit --no-verify -m "your message"
+```
+
+---
+
+## Performance
+
+| Files | Sequential | Parallel 4-core | Speedup |
+|-------|------------|-----------------|---------|
+| 100   | 3.2s       | 1.1s            | 2.9x    |
+| 500   | 16.8s      | 4.3s            | 3.9x    |
+| 1000  | 33.5s      | 7.1s            | 4.7x    |
+
+8 cores: 150-200 files/sec. SHA256 cache on unchanged files: 500-1000 files/sec.
+Workers default to CPU count. Override with `--workers N`.
+
+---
+
+## Testing
+
+```powershell
+Set-Location C:\Dev\PROJECTS\CODE
+.\.venv\Scripts\Activate.ps1
+
+python -m pytest -q
+python main.py --help
+```
+
+Test files in `tests/` cover the main tool plus all four launch/sales scripts.
+All 5 features tested on 2026-02-09 (see docs/TEST_REPORT.md). Manual confirmation
+of interactive mode still pending.
+
+---
+
+## Project Layout
+
+```
+CODE/
+  main.py                          -- Root entrypoint. Delegates to src/code_normalize_pro.py
+  src/
+    code_normalize_pro.py          -- v3.0 Pro. 917 lines. The active tool.
+    code_normalize_v2.py           -- v2.0. Kept for reference.
+  code_normalizer_pro/             -- PyPI package stub
+    __init__.py                    -- Exposes __version__ = "3.0.1"
+    cli.py                         -- Console entry point (calls src/code_normalize_pro.py)
+    README.md
+  config/
+    settings.py                    -- Env-var settings loader (not wired up yet)
+  docs/
+    README.md                      -- Full feature reference docs
+    TEST_REPORT.md                 -- Test results from 2026-02-09
+    ARCHITECTURE.md                -- Stub
+    launch/                        -- Outreach templates, user tracking CSV, metrics JSON
+    sales/                         -- Pricing, pipeline CSV, customer offer template
+    release/
+      alpha_release_checklist.md   -- Step-by-step PyPI publish checklist
+      release_readiness.json       -- Says ready=true, wheel+sdist listed
+  roadmaps/
+    README.md                      -- Overview of all 6 paths
+    01_solo_dev_tool.md            -- CHOSEN: bootstrap to PyPI
+    02_dev_tool_saas.md
+    03_enterprise_platform.md
+    04_open_source_support.md
+    05_grammarly_for_code.md
+    06_ai_transformation_engine.md
+  scripts/
+    launch_metrics.py
+    feedback_prioritizer.py
+    sales_pipeline_metrics.py
+    release_prep.py
+  tests/
+    test_code_normalize_pro.py
+    test_feedback_prioritizer.py
+    test_launch_metrics.py
+    test_release_prep.py
+    test_sales_pipeline_metrics.py
+  site/
+    index.html                     -- Static landing page
+    styles.css
+  .github/
+    workflows/ci.yml               -- CI: install, smoke check, pytest, build
+    ISSUE_TEMPLATE/
+    pull_request_template.md
+  files/
+    cache_sandbox/                 -- Test fixtures (a.py, b.py)
+    smoke_case.py
+  EXECUTION_PLAN.md                -- 7-day launch plan (all tasks pending)
+  VERIFY.md                        -- Verification runbook
+  MISSINGMORE.txt                  -- Gap tracking
+  QUICK_REFERENCE.md               -- Command cheat sheet
+  CHANGELOG.md                     -- Stub (unreleased only)
+```
+
+---
+
+## Dependencies
+
+Core: zero. Python 3.10+ only.
+
+Optional:
+- `tqdm` -- progress bars
+- Syntax checkers (only needed with `--check`):
+  Python: built-in (py_compile) | JS: node | TS: tsc | Go: gofmt
+  Rust: rustc | C: gcc | C++: g++ | Java: javac
+
+Dev/test: pytest (see requirements.txt)
+
+---
+
+## Known Issues (fix before PyPI launch)
+
+**Critical -- blocks shipping:**
+
+1. No `pyproject.toml` -- CI runs `python -m build` which will fail without it.
+   The `code_normalizer_pro.egg-info/` dir shows packaging was attempted but no
+   config file exists in the tree. Create `pyproject.toml` with src layout and
+   console_scripts entry point before running Day 1 tasks.
+
+2. `code_normalizer_pro/cli.py` has a broken import:
+   `from code_normalize_pro import main`
+   After `pip install`, Python looks for a module named `code_normalize_pro` in
+   site-packages, not in `src/`. Without a proper src layout in pyproject.toml,
+   the installed CLI command will fail on launch.
+
+**Code bugs worth fixing:**
+
+3. Cache default is on in `__init__` but `--cache` flag implies opt-in and
+   `--no-cache` implies opt-out. The flags and the default contradict each other.
+   Pick one direction and make the help text match.
+
+4. `--parallel --in-place` silently disables backups. `process_file_worker`
+   passes `create_backup=False` but backup logic only lives inside `process_file`.
+   Users running parallel mode have no backups. Either warn loudly or fix it.
+
+5. `walk_and_process` and `process_file` both increment `total_files` for the
+   same files. Summary stats will show inflated counts.
+
+6. `.normalize-cache.json` lands in CWD, not the target directory. Running the
+   tool against three different projects from the same shell session corrupts the
+   cache. Pass `root / CACHE_FILE` to CacheManager in `walk_and_process`.
+
+7. `--dry-run` always exits 0 even when it finds files needing normalization.
+   CI pipelines need a non-zero exit to catch violations. Add `--fail-on-changes`
+   or make dry-run exit 1 when changes are detected.
+
+**Cleanup:**
+
+8. `code_normalize_pro.py` at root -- stale copy. Real file is `src/`. Delete it.
+9. `roadmaps/New Text Document.txt` -- empty temp file. Delete it.
+10. `roadmaps/talking about code.txt` -- saved AI chat session. Delete or move to docs/.
+11. All `README_20260220_*.md.bak` files throughout the tree -- ReadmeForge backups.
+12. `config/settings.py` is a clean env-var loader but nothing imports it.
+    Either wire it into `code_normalize_pro.py` or remove it.
+13. `README_PRO.md` at root duplicates `docs/README.md`. Consolidate.
+14. `restore_report.json` and `smoke_report.json` at root -- generated artifacts,
+    add to `.gitignore`.
+15. `PROJECT_STATUS.md` says roadmap docs are "coming soon" -- all 6 exist. Stale.
+
+---
+
+## Launch Status (Path 1 - Solo Dev Tool)
+
+EXECUTION_PLAN.md has a 7-day checklist. As of 2026-03-10, nothing started.
+
+Before Day 1 tasks will work, pyproject.toml needs to exist (see issue #1 above).
+
+Day 1 after pyproject.toml is in place:
+
+```powershell
+Set-Location C:\Dev\PROJECTS\CODE
+.\.venv\Scripts\Activate.ps1
+python -m pytest -q
+pip install -e .
+code-normalizer-pro --help
+```
+
+Full release steps: see `docs/release/alpha_release_checklist.md`
+
+---
+
+## CI
+
+`.github/workflows/ci.yml` runs on push to main/master and on PRs:
+- Python 3.11
+- pip install from requirements.txt
+- CLI smoke check (main.py and src/code_normalize_pro.py --help)
+- pytest -q
+- python -m build (sdist + wheel)
+
+Note: `python -m build` requires `pyproject.toml`. CI will fail until that exists.
+
+---
+
+## Version History
+
+| Version | Date       | Changes |
+|---------|------------|---------|
+| v3.0    | 2026-02-09 | Parallel processing, SHA256 caching, pre-commit hooks, multi-language syntax, interactive mode |
+| v2.0    | 2026-02-09 | Dry-run, in-place editing, backups, tqdm, detailed stats |
+| v1.0    | --         | Basic encoding fix, CRLF, whitespace |
+
+Package version: 3.0.1 (set in `code_normalizer_pro/__init__.py`)
+
+---
+
+Developer: MR (Michael Rawls Jr.) -- Houston, TX -- GitHub: MRJR0101

code_normalizer_pro-3.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+code_normalizer_pro/__init__.py,sha256=d0Ji7B4QXO6YY6oMre61-nwRoX6gXK22drzGjek0NqE,98
+code_normalizer_pro/cli.py,sha256=dtpngEplOPZTuXHnPZhQr3H3U1SoEku2xNIF2lp9t2A,1322
+code_normalizer_pro/code_normalize_pro.py,sha256=VlKw_Om_HvJJlphpgZnYsyPAK3hPNnVKhUQFwz6IU3U,31749
+code_normalizer_pro-3.0.1.dist-info/licenses/LICENSE,sha256=dQVLagjhAIyGtgRauZrdLI-lcZh4gJUamSnxHuVqfWQ,1057
+code_normalizer_pro-3.0.1.dist-info/METADATA,sha256=wnk0GLXCmfNjO50bjOoj4KohIXxwFT66LgMmG4KzgHg,10701
+code_normalizer_pro-3.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+code_normalizer_pro-3.0.1.dist-info/entry_points.txt,sha256=gFQf6V2-Rbe-1ZpOcR2O1TCCxxwcYN6zblHuQ7W7JIE,69
+code_normalizer_pro-3.0.1.dist-info/top_level.txt,sha256=UYaCi8KON0Ez5W78NKGNbnyHHpAs_OH4t2MR5HBlOzE,20
+code_normalizer_pro-3.0.1.dist-info/RECORD,,

code_normalizer_pro-3.0.1.dist-info/WHEEL

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

code_normalizer_pro-3.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+code-normalizer-pro = code_normalizer_pro.cli:main

code_normalizer_pro-3.0.1.dist-info/licenses/LICENSE

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

code_normalizer_pro-3.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+code_normalizer_pro