Print Removal: How to A Step-by-Step Guide

import os
import subprocess
import json
import csv
from pathlib import Path
from typing import List, Dict, Optional

# Configuration: directories to exclude from audit
EXCLUDE_DIRS = {"node_modules", "__pycache__", "venv", ".git", "build", "dist"}
# Supported file extensions per language
LANG_EXTENSIONS = {
    "javascript": [".js", ".jsx", ".ts", ".tsx"],
    "python": [".py"],
    "java": [".java"]
}
# Print patterns per language (used for AST-grep rules)
PRINT_PATTERNS = {
    "javascript": "console.log($$$)",
    "python": "print($$$)",
    "java": "System.out.println($$$)"
}


def run_ast_grep(file_path: Path, lang: str) -> List[Dict]:
    """Run ast-grep on a single file to detect print statements.
    Args:
        file_path: Path to the file to scan
        lang: Language identifier (javascript, python, java)
    Returns:
        List of match dictionaries with line number and matched code
    """
    pattern = PRINT_PATTERNS.get(lang)
    if not pattern:
        raise ValueError(f"Unsupported language: {lang}")

    try:
        # Run ast-grep with JSON output for parsing
        result = subprocess.run(
            ["ast-grep", "scan", "--pattern", pattern, "--json", str(file_path)],
            capture_output=True,
            text=True,
            check=False  # Don't raise on non-zero exit (ast-grep returns 1 if matches found)
        )
        # Parse JSON output from ast-grep
        matches = json.loads(result.stdout) if result.stdout else []
        return matches
    except FileNotFoundError:
        raise RuntimeError("ast-grep is not installed. Install via `npm install -g ast-grep` or `cargo install ast-grep`")
    except json.JSONDecodeError:
        print(f"Warning: Failed to parse ast-grep output for {file_path}")
        return []


def audit_codebase(root_dir: Path, output_csv: Path) -> None:
    """Audit an entire codebase for print statements, write results to CSV.
    Args:
        root_dir: Root directory of the codebase to scan
        output_csv: Path to write CSV results
    """
    results = []

    for file_path in root_dir.rglob("*"):
        # Skip excluded directories
        if any(excl in file_path.parts for excl in EXCLUDE_DIRS):
            continue
        # Skip non-files
        if not file_path.is_file():
            continue

        # Determine language from file extension
        lang = None
        for lang_name, exts in LANG_EXTENSIONS.items():
            if file_path.suffix in exts:
                lang = lang_name
                break
        if not lang:
            continue

        # Run scan for this file
        try:
            matches = run_ast_grep(file_path, lang)
            for match in matches:
                results.append({
                    "file_path": str(file_path),
                    "language": lang,
                    "line_number": match.get("start", {}).get("line", "unknown"),
                    "matched_code": match.get("text", ""),
                    "rule": PRINT_PATTERNS[lang]
                })
        except RuntimeError as e:
            print(f"Error scanning {file_path}: {e}")
            continue

    # Write results to CSV
    if results:
        with open(output_csv, "w", newline="") as f:
            writer = csv.DictWriter(f, fieldnames=["file_path", "language", "line_number", "matched_code", "rule"])
            writer.writeheader()
            writer.writerows(results)
        print(f"Audit complete. Found {len(results)} print statements. Results written to {output_csv}")
    else:
        print("No print statements found in codebase.")


if __name__ == "__main__":
    # Example usage: audit current directory, write to audit_results.csv
    import sys
    root = Path(sys.argv[1]) if len(sys.argv) > 1 else Path.cwd()
    output = Path(sys.argv[2]) if len(sys.argv) > 2 else Path("audit_results.csv")

    if not root.exists() or not root.is_dir():
        print(f"Error: {root} is not a valid directory")
        sys.exit(1)

    audit_codebase(root, output)

import yaml
import re
from pathlib import Path
from typing import List, Dict, Set, Optional
from dataclasses import dataclass

@dataclass
class PrintWhitelistRule:
    """Rule for whitelisting print statements that should NOT be removed."""
    language: str
    pattern: Optional[str]  # Regex pattern for matched code, or None for all prints in file
    file_path_pattern: Optional[str]  # Regex pattern for file paths, or None for all files
    description: str

class PrintWhitelist:
    """Manages whitelist rules for print removal."""
    def __init__(self, whitelist_path: Path):
        self.whitelist_path = whitelist_path
        self.rules: List[PrintWhitelistRule] = []
        self._load_whitelist()

    def _load_whitelist(self) -> None:
        """Load whitelist rules from YAML config file."""
        if not self.whitelist_path.exists():
            raise FileNotFoundError(f"Whitelist file not found: {self.whitelist_path}")

        try:
            with open(self.whitelist_path, "r") as f:
                config = yaml.safe_load(f)
        except yaml.YAMLError as e:
            raise ValueError(f"Invalid YAML in whitelist: {e}")

        # Parse rules from config
        for rule_config in config.get("rules", []):
            required_fields = ["language", "description"]
            for field in required_fields:
                if field not in rule_config:
                    raise ValueError(f"Rule missing required field: {field}")

            rule = PrintWhitelistRule(
                language=rule_config["language"],
                pattern=rule_config.get("pattern"),
                file_path_pattern=rule_config.get("file_path_pattern"),
                description=rule_config["description"]
            )
            self.rules.append(rule)

    def is_whitelisted(self, file_path: Path, language: str, matched_code: str) -> bool:
        """Check if a print statement is whitelisted.
        Args:
            file_path: Path to the file containing the print
            language: Language of the file
            matched_code: The actual print statement code matched
        Returns:
            True if the print is whitelisted (should not be removed)
        """
        for rule in self.rules:
            # Match language first
            if rule.language != language:
                continue

            # Match file path pattern if specified
            if rule.file_path_pattern:
                file_regex = re.compile(rule.file_path_pattern)
                if not file_regex.search(str(file_path)):
                    continue

            # Match code pattern if specified
            if rule.pattern:
                code_regex = re.compile(rule.pattern)
                if not code_regex.search(matched_code):
                    continue

            # If we got here, all specified criteria match
            return True
        return False

    def get_whitelisted_count(self, audit_results: List[Dict]) -> int:
        """Count how many audit results are whitelisted.
        Args:
            audit_results: List of audit result dicts from Step 1
        Returns:
            Number of whitelisted print statements
        """
        count = 0
        for result in audit_results:
            file_path = Path(result["file_path"])
            language = result["language"]
            matched_code = result["matched_code"]
            if self.is_whitelisted(file_path, language, matched_code):
                count +=1
        return count

def load_audit_results(csv_path: Path) -> List[Dict]:
    """Load audit results from CSV file."""
    import csv
    results = []
    with open(csv_path, "r") as f:
        reader = csv.DictReader(f)
        for row in reader:
            results.append(row)
    return results

if __name__ == "__main__":
    # Example usage: load whitelist, check audit results
    import sys
    whitelist_path = Path(sys.argv[1]) if len(sys.argv) >1 else Path("print_whitelist.yaml")
    audit_csv = Path(sys.argv[2]) if len(sys.argv) >2 else Path("audit_results.csv")

    try:
        whitelist = PrintWhitelist(whitelist_path)
        print(f"Loaded {len(whitelist.rules)} whitelist rules")
    except Exception as e:
        print(f"Error loading whitelist: {e}")
        sys.exit(1)

    if audit_csv.exists():
        audit_results = load_audit_results(audit_csv)
        whitelisted = whitelist.get_whitelisted_count(audit_results)
        print(f"Total audit results: {len(audit_results)}")
        print(f"Whitelisted (to keep): {whitelisted}")
        print(f"To remove: {len(audit_results) - whitelisted}")
    else:
        print("No audit results found. Run Step 1 audit first.")

import csv
import json
import subprocess
from pathlib import Path
from typing import List, Dict
from print_whitelist import PrintWhitelist  # Assumes Step 2's class is in this file

# Mapping of language to AST removal tool
REMOVAL_TOOLS = {
    "javascript": "babel",
    "python": "python_ast",
    "java": "java_parser"
}

def remove_js_prints(file_path: Path, whitelist: PrintWhitelist) -> None:
    """Remove non-whitelisted print statements from JavaScript/TypeScript files using Babel."""
    # Custom Babel plugin to remove console.log statements
    babel_plugin = """
module.exports = function() {
    return {
        visitor: {
            CallExpression(path) {
                const callee = path.get("callee");
                if (callee.matchesPattern("console.log")) {
                    // Get file path and code for whitelist check
                    const filePath = process.env.CURRENT_FILE_PATH;
                    const code = path.toString();
                    // In practice, pass to whitelist check here
                    path.remove();
                }
            }
        }
    };
}
"""
    # Write temporary Babel plugin
    plugin_path = Path("temp_babel_plugin.js")
    with open(plugin_path, "w") as f:
        f.write(babel_plugin)

    try:
        # Run Babel with custom plugin to remove prints
        result = subprocess.run(
            ["babel", str(file_path), "--plugins", str(plugin_path), "--out-file", str(file_path)],
            capture_output=True,
            text=True,
            check=True,
            env={"CURRENT_FILE_PATH": str(file_path)}
        )
        print(f"Processed JS file: {file_path}")
    except subprocess.CalledProcessError as e:
        print(f"Error processing JS file {file_path}: {e.stderr}")
    finally:
        # Clean up temporary plugin
        if plugin_path.exists():
            plugin_path.unlink()

def remove_python_prints(file_path: Path, whitelist: PrintWhitelist) -> None:
    """Remove non-whitelisted print statements from Python files using ast module."""
    import ast
    import astor  # Requires astor: pip install astor

    class PrintRemover(ast.NodeTransformer):
        def __init__(self, file_path: Path, whitelist: PrintWhitelist):
            self.file_path = file_path
            self.whitelist = whitelist

        def visit_Call(self, node):
            # Check if this is a print call
            if isinstance(node.func, ast.Name) and node.func.id == "print":
                # Get the code of the print statement
                code = astor.to_source(node).strip()
                # Check if whitelisted
                if not self.whitelist.is_whitelisted(self.file_path, "python", code):
                    # Remove the node
                    return None
            return node

    try:
        # Read original file
        with open(file_path, "r") as f:
            source = f.read()

        # Parse AST
        tree = ast.parse(source)

        # Transform tree to remove non-whitelisted prints
        remover = PrintRemover(file_path, whitelist)
        new_tree = remover.visit(tree)

        # Generate new source code
        new_source = astor.to_source(new_tree).strip()

        # Write back to file
        with open(file_path, "w") as f:
            f.write(new_source)

        print(f"Processed Python file: {file_path}")
    except Exception as e:
        print(f"Error processing Python file {file_path}: {e}")

def process_audit_results(audit_csv: Path, whitelist: PrintWhitelist) -> None:
    """Process all audit results, remove non-whitelisted prints."""
    with open(audit_csv, "r") as f:
        reader = csv.DictReader(f)
        for row in reader:
            file_path = Path(row["file_path"])
            language = row["language"]
            matched_code = row["matched_code"]

            # Skip whitelisted prints
            if whitelist.is_whitelisted(file_path, language, matched_code):
                continue

            # Process file based on language
            if language == "javascript":
                remove_js_prints(file_path, whitelist)
            elif language == "python":
                remove_python_prints(file_path, whitelist)
            elif language == "java":
                print(f"Java removal: process {file_path} (implementation in GitHub repo)")
            else:
                print(f"Unsupported language {language} for {file_path}")

if __name__ == "__main__":
    import sys
    audit_csv = Path(sys.argv[1]) if len(sys.argv) >1 else Path("audit_results.csv")
    whitelist_path = Path(sys.argv[2]) if len(sys.argv) >2 else Path("print_whitelist.yaml")

    if not audit_csv.exists():
        print(f"Audit CSV not found: {audit_csv}")
        sys.exit(1)

    try:
        whitelist = PrintWhitelist(whitelist_path)
    except Exception as e:
        print(f"Error loading whitelist: {e}")
        sys.exit(1)

    process_audit_results(audit_csv, whitelist)
    print("Print removal complete.")

sed -i 's/console.log(.*)//g' src/**/*.js  # High false positive rate

ast-grep scan --pattern 'console.log($$$)' --json src/  # Only matches real calls

rules:
  - language: javascript
    file_path_pattern: "src/tests/**/*.js"
    description: "Keep all prints in test files"
  - language: python
    pattern: "logging.error($$$)"
    description: "Keep error logging calls"

repos:
  - repo: local
    hooks:
      - id: print-audit
        name: Audit for debug prints
        entry: python audit/audit_codebase.py .
        language: system
        files: '\\.(js|py|java)$'

print-removal-pipeline/
├── audit/
│   ├── audit_codebase.py
│   └── requirements.txt
├── whitelist/
│   ├── print_whitelist.py
│   └── print_whitelist.yaml
├── removal/
│   ├── remove_prints.py
│   └── babel_plugin.js
├── ci/
│   └── github_actions_print_check.yaml
├── tests/
│   ├── test_audit.py
│   └── test_removal.py
├── README.md
└── LICENSE