thailint 0.2.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

src/cli.py

@@ -59,12 +59,145 @@ def setup_logging(verbose: bool = False):
     )
 
 
+def _determine_project_root(
+    explicit_root: str | None, config_path: str | None, verbose: bool
+) -> Path:
+    """Determine project root with precedence rules.
+
+    Precedence order:
+    1. Explicit --project-root (highest priority)
+    2. Inferred from --config path directory
+    3. Auto-detection via get_project_root() (fallback)
+
+    Args:
+        explicit_root: Explicitly specified project root path (from --project-root)
+        config_path: Config file path (from --config)
+        verbose: Whether verbose logging is enabled
+
+    Returns:
+        Path to determined project root
+
+    Raises:
+        SystemExit: If explicit_root doesn't exist or is not a directory
+    """
+    from src.utils.project_root import get_project_root
+
+    # Priority 1: Explicit --project-root
+    if explicit_root:
+        return _resolve_explicit_project_root(explicit_root, verbose)
+
+    # Priority 2: Infer from --config path
+    if config_path:
+        return _infer_root_from_config(config_path, verbose)
+
+    # Priority 3: Auto-detection (fallback)
+    return _autodetect_project_root(verbose, get_project_root)
+
+
+def _resolve_explicit_project_root(explicit_root: str, verbose: bool) -> Path:
+    """Resolve and validate explicitly specified project root.
+
+    Args:
+        explicit_root: Explicitly specified project root path
+        verbose: Whether verbose logging is enabled
+
+    Returns:
+        Resolved project root path
+
+    Raises:
+        SystemExit: If explicit_root doesn't exist or is not a directory
+    """
+    root = Path(explicit_root)
+    # Check existence before resolving to handle relative paths in test environments
+    if not root.exists():
+        click.echo(f"Error: Project root does not exist: {explicit_root}", err=True)
+        sys.exit(2)
+    if not root.is_dir():
+        click.echo(f"Error: Project root must be a directory: {explicit_root}", err=True)
+        sys.exit(2)
+
+    # Now resolve after validation
+    root = root.resolve()
+
+    if verbose:
+        logger.debug(f"Using explicit project root: {root}")
+    return root
+
+
+def _infer_root_from_config(config_path: str, verbose: bool) -> Path:
+    """Infer project root from config file path.
+
+    Args:
+        config_path: Config file path
+        verbose: Whether verbose logging is enabled
+
+    Returns:
+        Inferred project root (parent directory of config file)
+    """
+    config_file = Path(config_path).resolve()
+    inferred_root = config_file.parent
+
+    if verbose:
+        logger.debug(f"Inferred project root from config path: {inferred_root}")
+    return inferred_root
+
+
+def _autodetect_project_root(verbose: bool, get_project_root) -> Path:
+    """Auto-detect project root using project root detection.
+
+    Args:
+        verbose: Whether verbose logging is enabled
+        get_project_root: Function to detect project root
+
+    Returns:
+        Auto-detected project root
+    """
+    auto_root = get_project_root(None)
+    if verbose:
+        logger.debug(f"Auto-detected project root: {auto_root}")
+    return auto_root
+
+
+def _get_project_root_from_context(ctx) -> Path:
+    """Get or determine project root from Click context.
+
+    This function defers the actual determination until needed to avoid
+    importing pyprojroot in test environments where it may not be available.
+
+    Args:
+        ctx: Click context containing CLI options
+
+    Returns:
+        Path to determined project root
+    """
+    # Check if already determined and cached
+    if "project_root" in ctx.obj:
+        return ctx.obj["project_root"]
+
+    # Determine project root using stored CLI options
+    explicit_root = ctx.obj.get("cli_project_root")
+    config_path = ctx.obj.get("cli_config_path")
+    verbose = ctx.obj.get("verbose", False)
+
+    project_root = _determine_project_root(explicit_root, config_path, verbose)
+
+    # Cache for future use
+    ctx.obj["project_root"] = project_root
+
+    return project_root
+
+
 @click.group()
 @click.version_option(version=__version__)
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose output")
 @click.option("--config", "-c", type=click.Path(), help="Path to config file")
+@click.option(
+    "--project-root",
+    type=click.Path(),
+    help="Explicitly specify project root directory (overrides auto-detection)",
+)
 @click.pass_context
-def cli(ctx, verbose: bool, config: str | None):
+def cli(ctx, verbose: bool, config: str | None, project_root: str | None):
     """
     thai-lint - AI code linter and governance tool
 
@@ -85,6 +218,10 @@ def cli(ctx, verbose: bool, config: str | None):
         # Lint with custom config
         thai-lint file-placement --config .thailint.yaml src/
 
+        \b
+        # Specify project root explicitly (useful in Docker)
+        thai-lint --project-root /workspace/root magic-numbers backend/
+
         \b
         # Get JSON output
         thai-lint file-placement --format json .
@@ -99,6 +236,11 @@ def cli(ctx, verbose: bool, config: str | None):
     # Setup logging
     setup_logging(verbose)
 
+    # Store CLI options for later project root determination
+    # (deferred to avoid pyprojroot import issues in test environments)
+    ctx.obj["cli_project_root"] = project_root
+    ctx.obj["cli_config_path"] = config
+
     # Load configuration
     try:
         if config:
@@ -362,8 +504,143 @@ def config_reset(ctx, yes: bool):
         sys.exit(1)
 
 
+@cli.command("init-config")
+@click.option(
+    "--preset",
+    "-p",
+    type=click.Choice(["strict", "standard", "lenient"]),
+    default="standard",
+    help="Configuration preset",
+)
+@click.option("--non-interactive", is_flag=True, help="Skip interactive prompts (for AI agents)")
+@click.option("--force", is_flag=True, help="Overwrite existing .thailint.yaml file")
+@click.option(
+    "--output", "-o", type=click.Path(), default=".thailint.yaml", help="Output file path"
+)
+def init_config(preset: str, non_interactive: bool, force: bool, output: str):
+    """
+    Generate a .thailint.yaml configuration file with preset values.
+
+    Creates a richly-commented configuration file with sensible defaults
+    and optional customizations for different strictness levels.
+
+    For AI agents, use --non-interactive mode:
+      thailint init-config --non-interactive --preset lenient
+
+    Presets:
+      strict:   Minimal allowed numbers (only -1, 0, 1)
+      standard: Balanced defaults (includes 2, 3, 4, 5, 10, 100, 1000)
+      lenient:  Includes time conversions (adds 60, 3600)
+
+    Examples:
+
+        \\b
+        # Interactive mode (default, for humans)
+        thailint init-config
+
+        \\b
+        # Non-interactive mode (for AI agents)
+        thailint init-config --non-interactive
+
+        \\b
+        # Generate with lenient preset
+        thailint init-config --preset lenient
+
+        \\b
+        # Overwrite existing config
+        thailint init-config --force
+
+        \\b
+        # Custom output path
+        thailint init-config --output my-config.yaml
+    """
+    output_path = Path(output)
+
+    # Check if file exists (unless --force)
+    if output_path.exists() and not force:
+        click.echo(f"Error: {output} already exists", err=True)
+        click.echo("", err=True)
+        click.echo("Use --force to overwrite:", err=True)
+        click.echo("  thailint init-config --force", err=True)
+        sys.exit(1)
+
+    # Interactive mode: Ask user for preferences
+    if not non_interactive:
+        click.echo("thai-lint Configuration Generator")
+        click.echo("=" * 50)
+        click.echo("")
+        click.echo("This will create a .thailint.yaml configuration file.")
+        click.echo("For non-interactive mode (AI agents), use:")
+        click.echo("  thailint init-config --non-interactive")
+        click.echo("")
+
+        # Ask for preset
+        click.echo("Available presets:")
+        click.echo("  strict:   Only -1, 0, 1 allowed (strictest)")
+        click.echo("  standard: -1, 0, 1, 2, 3, 4, 5, 10, 100, 1000 (balanced)")
+        click.echo("  lenient:  Includes time conversions 60, 3600 (most permissive)")
+        click.echo("")
+
+        preset = click.prompt(
+            "Choose preset", type=click.Choice(["strict", "standard", "lenient"]), default=preset
+        )
+
+    # Generate config based on preset
+    config_content = _generate_config_content(preset)
+
+    # Write config file
+    try:
+        output_path.write_text(config_content, encoding="utf-8")
+        click.echo("")
+        click.echo(f"✓ Created {output}")
+        click.echo(f"✓ Preset: {preset}")
+        click.echo("")
+        click.echo("Next steps:")
+        click.echo(f"  1. Review and customize {output}")
+        click.echo("  2. Run: thailint magic-numbers .")
+        click.echo("  3. See docs: https://github.com/your-org/thai-lint")
+    except OSError as e:
+        click.echo(f"Error writing config file: {e}", err=True)
+        sys.exit(1)
+
+
+def _generate_config_content(preset: str) -> str:
+    """Generate config file content based on preset."""
+    # Preset configurations
+    presets = {
+        "strict": {
+            "allowed_numbers": "[-1, 0, 1]",
+            "max_small_integer": "3",
+            "description": "Strict (only universal values)",
+        },
+        "standard": {
+            "allowed_numbers": "[-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000]",
+            "max_small_integer": "10",
+            "description": "Standard (balanced defaults)",
+        },
+        "lenient": {
+            "allowed_numbers": "[-1, 0, 1, 2, 3, 4, 5, 10, 60, 100, 1000, 3600]",
+            "max_small_integer": "10",
+            "description": "Lenient (includes time conversions)",
+        },
+    }
+
+    config = presets[preset]
+
+    # Read template
+    template_path = Path(__file__).parent / "templates" / "thailint_config_template.yaml"
+    template = template_path.read_text(encoding="utf-8")
+
+    # Replace placeholders
+    content = template.replace("{{PRESET}}", config["description"])
+    content = content.replace("{{ALLOWED_NUMBERS}}", config["allowed_numbers"])
+    content = content.replace("{{MAX_SMALL_INTEGER}}", config["max_small_integer"])
+
+    return content
+
+
 @cli.command("file-placement")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @click.option("--rules", "-r", help="Inline JSON rules configuration")
 @format_option
@@ -416,6 +693,7 @@ def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-ar
         thai-lint file-placement --rules '{"allow": [".*\\.py$"]}' .
     """
     verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
 
     if not paths:
         paths = (".",)
@@ -423,16 +701,19 @@ def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-ar
     path_objs = [Path(p) for p in paths]
 
     try:
-        _execute_file_placement_lint(path_objs, config_file, rules, format, recursive, verbose)
+        _execute_file_placement_lint(
+            path_objs, config_file, rules, format, recursive, verbose, project_root
+        )
     except Exception as e:
         _handle_linting_error(e, verbose)
 
 
 def _execute_file_placement_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    path_objs, config_file, rules, format, recursive, verbose
+    path_objs, config_file, rules, format, recursive, verbose, project_root=None
 ):
     """Execute file placement linting."""
-    orchestrator = _setup_orchestrator(path_objs, config_file, rules, verbose)
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_orchestrator(path_objs, config_file, rules, verbose, project_root)
     all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
 
     # Filter to only file-placement violations
@@ -453,6 +734,28 @@ def _handle_linting_error(error: Exception, verbose: bool) -> None:
     sys.exit(2)
 
 
+def _validate_paths_exist(path_objs: list[Path]) -> None:
+    """Validate that all provided paths exist.
+
+    Args:
+        path_objs: List of Path objects to validate
+
+    Raises:
+        SystemExit: If any path doesn't exist (exit code 2)
+    """
+    for path in path_objs:
+        if not path.exists():
+            click.echo(f"Error: Path does not exist: {path}", err=True)
+            click.echo("", err=True)
+            click.echo(
+                "Hint: When using Docker, ensure paths are inside the mounted volume:", err=True
+            )
+            click.echo(
+                "  docker run -v $(pwd):/data thailint <command> /data/your-file.py", err=True
+            )
+            sys.exit(2)
+
+
 def _find_project_root(start_path: Path) -> Path:
     """Find project root by looking for .git or pyproject.toml.
 
@@ -469,26 +772,55 @@ def _find_project_root(start_path: Path) -> Path:
     return get_project_root(start_path)
 
 
-def _setup_orchestrator(path_objs, config_file, rules, verbose):
+def _setup_orchestrator(path_objs, config_file, rules, verbose, project_root=None):
     """Set up and configure the orchestrator."""
     from src.orchestrator.core import Orchestrator
     from src.utils.project_root import get_project_root
 
+    # Use provided project_root or fall back to auto-detection
+    project_root = _get_or_detect_project_root(path_objs, project_root, get_project_root)
+
+    orchestrator = Orchestrator(project_root=project_root)
+    _apply_orchestrator_config(orchestrator, config_file, rules, verbose)
+
+    return orchestrator
+
+
+def _get_or_detect_project_root(path_objs, project_root, get_project_root):
+    """Get provided project root or auto-detect from paths.
+
+    Args:
+        path_objs: List of path objects
+        project_root: Optionally provided project root
+        get_project_root: Function to detect project root
+
+    Returns:
+        Project root path
+    """
+    if project_root is not None:
+        return project_root
+
     # Find actual project root (where .git or pyproject.toml exists)
     # This ensures .artifacts/ is always created at project root, not in subdirectories
     first_path = path_objs[0] if path_objs else Path.cwd()
     search_start = first_path if first_path.is_dir() else first_path.parent
-    project_root = get_project_root(search_start)
+    return get_project_root(search_start)
 
-    orchestrator = Orchestrator(project_root=project_root)
 
+def _apply_orchestrator_config(orchestrator, config_file, rules, verbose):
+    """Apply configuration to orchestrator.
+
+    Args:
+        orchestrator: Orchestrator instance
+        config_file: Path to config file (optional)
+        rules: Inline JSON rules (optional)
+        verbose: Whether verbose logging is enabled
+    """
     if rules:
         _apply_inline_rules(orchestrator, rules, verbose)
     elif config_file:
         _load_config_file(orchestrator, config_file, verbose)
 
-    return orchestrator
-
 
 def _apply_inline_rules(orchestrator, rules, verbose):
     """Parse and apply inline JSON rules."""
@@ -601,13 +933,18 @@ def _execute_linting_on_paths(orchestrator, path_objs: list[Path], recursive: bo
     return violations
 
 
-def _setup_nesting_orchestrator(path_objs: list[Path], config_file: str | None, verbose: bool):
+def _setup_nesting_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
     """Set up orchestrator for nesting command."""
-    # Use first path to determine project root
-    first_path = path_objs[0] if path_objs else Path.cwd()
-    project_root = first_path if first_path.is_dir() else first_path.parent
-
     from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    # Use provided project_root or fall back to auto-detection
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
 
     orchestrator = Orchestrator(project_root=project_root)
 
@@ -622,14 +959,34 @@ def _apply_nesting_config_override(orchestrator, max_depth: int | None, verbose:
     if max_depth is None:
         return
 
+    # Ensure nesting config exists
     if "nesting" not in orchestrator.config:
         orchestrator.config["nesting"] = {}
-    orchestrator.config["nesting"]["max_nesting_depth"] = max_depth
+
+    nesting_config = orchestrator.config["nesting"]
+
+    # Set top-level max_nesting_depth
+    nesting_config["max_nesting_depth"] = max_depth
+
+    # Override language-specific configs to ensure CLI option takes precedence
+    _override_language_specific_nesting(nesting_config, max_depth)
 
     if verbose:
         logger.debug(f"Overriding max_nesting_depth to {max_depth}")
 
 
+def _override_language_specific_nesting(nesting_config: dict, max_depth: int):
+    """Override language-specific nesting depth configs.
+
+    Args:
+        nesting_config: Nesting configuration dictionary
+        max_depth: Maximum nesting depth to set
+    """
+    for lang in ["python", "typescript", "javascript"]:
+        if lang in nesting_config:
+            nesting_config[lang]["max_nesting_depth"] = max_depth
+
+
 def _run_nesting_lint(orchestrator, path_objs: list[Path], recursive: bool):
     """Execute nesting lint on files or directories."""
     all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
@@ -637,7 +994,7 @@ def _run_nesting_lint(orchestrator, path_objs: list[Path], recursive: bool):
 
 
 @cli.command("nesting")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @format_option
 @click.option("--max-depth", type=int, help="Override max nesting depth (default: 4)")
@@ -693,6 +1050,7 @@ def nesting(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         thai-lint nesting --config .thailint.yaml src/
     """
     verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
 
     # Default to current directory if no paths provided
     if not paths:
@@ -701,16 +1059,19 @@ def nesting(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     path_objs = [Path(p) for p in paths]
 
     try:
-        _execute_nesting_lint(path_objs, config_file, format, max_depth, recursive, verbose)
+        _execute_nesting_lint(
+            path_objs, config_file, format, max_depth, recursive, verbose, project_root
+        )
     except Exception as e:
         _handle_linting_error(e, verbose)
 
 
 def _execute_nesting_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    path_objs, config_file, format, max_depth, recursive, verbose
+    path_objs, config_file, format, max_depth, recursive, verbose, project_root=None
 ):
     """Execute nesting lint."""
-    orchestrator = _setup_nesting_orchestrator(path_objs, config_file, verbose)
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_nesting_orchestrator(path_objs, config_file, verbose, project_root)
     _apply_nesting_config_override(orchestrator, max_depth, verbose)
     nesting_violations = _run_nesting_lint(orchestrator, path_objs, recursive)
 
@@ -721,12 +1082,18 @@ def _execute_nesting_lint(  # pylint: disable=too-many-arguments,too-many-positi
     sys.exit(1 if nesting_violations else 0)
 
 
-def _setup_srp_orchestrator(path_objs: list[Path], config_file: str | None, verbose: bool):
+def _setup_srp_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
     """Set up orchestrator for SRP command."""
-    first_path = path_objs[0] if path_objs else Path.cwd()
-    project_root = first_path if first_path.is_dir() else first_path.parent
-
     from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    # Use provided project_root or fall back to auto-detection
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
 
     orchestrator = Orchestrator(project_root=project_root)
 
@@ -773,7 +1140,7 @@ def _run_srp_lint(orchestrator, path_objs: list[Path], recursive: bool):
 
 
 @cli.command("srp")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @format_option
 @click.option("--max-methods", type=int, help="Override max methods per class (default: 7)")
@@ -829,6 +1196,7 @@ def srp(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         thai-lint srp --config .thailint.yaml src/
     """
     verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
 
     if not paths:
         paths = (".",)
@@ -836,16 +1204,19 @@ def srp(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     path_objs = [Path(p) for p in paths]
 
     try:
-        _execute_srp_lint(path_objs, config_file, format, max_methods, max_loc, recursive, verbose)
+        _execute_srp_lint(
+            path_objs, config_file, format, max_methods, max_loc, recursive, verbose, project_root
+        )
     except Exception as e:
         _handle_linting_error(e, verbose)
 
 
 def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    path_objs, config_file, format, max_methods, max_loc, recursive, verbose
+    path_objs, config_file, format, max_methods, max_loc, recursive, verbose, project_root=None
 ):
     """Execute SRP lint."""
-    orchestrator = _setup_srp_orchestrator(path_objs, config_file, verbose)
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_srp_orchestrator(path_objs, config_file, verbose, project_root)
     _apply_srp_config_override(orchestrator, max_methods, max_loc, verbose)
     srp_violations = _run_srp_lint(orchestrator, path_objs, recursive)
 
@@ -857,7 +1228,7 @@ def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional
 
 
 @cli.command("dry")
-@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @format_option
 @click.option("--min-lines", type=int, help="Override min duplicate lines threshold")
@@ -925,6 +1296,7 @@ def dry(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         thai-lint dry --format json .
     """
     verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
 
     if not paths:
         paths = (".",)
@@ -933,17 +1305,34 @@ def dry(  # pylint: disable=too-many-arguments,too-many-positional-arguments
 
     try:
         _execute_dry_lint(
-            path_objs, config_file, format, min_lines, no_cache, clear_cache, recursive, verbose
+            path_objs,
+            config_file,
+            format,
+            min_lines,
+            no_cache,
+            clear_cache,
+            recursive,
+            verbose,
+            project_root,
         )
     except Exception as e:
         _handle_linting_error(e, verbose)
 
 
 def _execute_dry_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    path_objs, config_file, format, min_lines, no_cache, clear_cache, recursive, verbose
+    path_objs,
+    config_file,
+    format,
+    min_lines,
+    no_cache,
+    clear_cache,
+    recursive,
+    verbose,
+    project_root=None,
 ):
     """Execute DRY linting."""
-    orchestrator = _setup_dry_orchestrator(path_objs, config_file, verbose)
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_dry_orchestrator(path_objs, config_file, verbose, project_root)
     _apply_dry_config_override(orchestrator, min_lines, no_cache, verbose)
 
     if clear_cache:
@@ -958,14 +1347,16 @@ def _execute_dry_lint(  # pylint: disable=too-many-arguments,too-many-positional
     sys.exit(1 if dry_violations else 0)
 
 
-def _setup_dry_orchestrator(path_objs, config_file, verbose):
+def _setup_dry_orchestrator(path_objs, config_file, verbose, project_root=None):
     """Set up orchestrator for DRY linting."""
     from src.orchestrator.core import Orchestrator
     from src.utils.project_root import get_project_root
 
-    first_path = path_objs[0] if path_objs else Path.cwd()
-    search_start = first_path if first_path.is_dir() else first_path.parent
-    project_root = get_project_root(search_start)
+    # Use provided project_root or fall back to auto-detection
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
 
     orchestrator = Orchestrator(project_root=project_root)
 
@@ -1051,5 +1442,224 @@ def _run_dry_lint(orchestrator, path_objs, recursive):
     return dry_violations
 
 
+def _setup_magic_numbers_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
+    """Set up orchestrator for magic-numbers command."""
+    from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    # Use provided project_root or fall back to auto-detection
+    if project_root is None:
+        # Find actual project root (where .git or .thailint.yaml exists)
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _run_magic_numbers_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute magic-numbers lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "magic-number" in v.rule_id]
+
+
+@cli.command("magic-numbers")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def magic_numbers(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+):
+    """Check for magic numbers in code.
+
+    Detects unnamed numeric literals in Python and TypeScript/JavaScript code
+    that should be extracted as named constants for better readability.
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint magic-numbers
+
+        \b
+        # Check specific directory
+        thai-lint magic-numbers src/
+
+        \b
+        # Check single file
+        thai-lint magic-numbers src/app.py
+
+        \b
+        # Check multiple files
+        thai-lint magic-numbers src/app.py src/utils.py tests/test_app.py
+
+        \b
+        # Check mix of files and directories
+        thai-lint magic-numbers src/app.py tests/
+
+        \b
+        # Get JSON output
+        thai-lint magic-numbers --format json .
+
+        \b
+        # Use custom config file
+        thai-lint magic-numbers --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_magic_numbers_lint(
+            path_objs, config_file, format, recursive, verbose, project_root
+        )
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_magic_numbers_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, recursive, verbose, project_root=None
+):
+    """Execute magic-numbers lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_magic_numbers_orchestrator(path_objs, config_file, verbose, project_root)
+    magic_numbers_violations = _run_magic_numbers_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(magic_numbers_violations)} magic number violation(s)")
+
+    format_violations(magic_numbers_violations, format)
+    sys.exit(1 if magic_numbers_violations else 0)
+
+
+# =============================================================================
+# Print Statements Linter Command
+# =============================================================================
+
+
+def _setup_print_statements_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+):
+    """Set up orchestrator for print-statements command."""
+    from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    if project_root is None:
+        first_path = path_objs[0] if path_objs else Path.cwd()
+        search_start = first_path if first_path.is_dir() else first_path.parent
+        project_root = get_project_root(search_start)
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _run_print_statements_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute print-statements lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "print-statement" in v.rule_id]
+
+
+@cli.command("print-statements")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def print_statements(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    recursive: bool,
+):
+    """Check for print/console statements in code.
+
+    Detects print() calls in Python and console.log/warn/error/debug/info calls
+    in TypeScript/JavaScript that should be replaced with proper logging.
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint print-statements
+
+        \b
+        # Check specific directory
+        thai-lint print-statements src/
+
+        \b
+        # Check single file
+        thai-lint print-statements src/app.py
+
+        \b
+        # Check multiple files
+        thai-lint print-statements src/app.py src/utils.ts tests/test_app.py
+
+        \b
+        # Get JSON output
+        thai-lint print-statements --format json .
+
+        \b
+        # Use custom config file
+        thai-lint print-statements --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+    project_root = _get_project_root_from_context(ctx)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_print_statements_lint(
+            path_objs, config_file, format, recursive, verbose, project_root
+        )
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_print_statements_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, recursive, verbose, project_root=None
+):
+    """Execute print-statements lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_print_statements_orchestrator(
+        path_objs, config_file, verbose, project_root
+    )
+    print_statements_violations = _run_print_statements_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(print_statements_violations)} print statement violation(s)")
+
+    format_violations(print_statements_violations, format)
+    sys.exit(1 if print_statements_violations else 0)
+
+
 if __name__ == "__main__":
     cli()