dockerbrain 1.0__py3-none-any.whl

core/cli.py

@@ -0,0 +1,369 @@
+import platform
+import click
+from core import __version__
+
+def print_version(ctx: click.Context, _param: click.Parameter, value: bool) -> None:
+    """Print version with build metadata and exit."""
+    if not value or ctx.resilient_parsing:
+        return
+    click.echo(
+        f"dockerbrain v{__version__} "
+        f"(Python {platform.python_version()}, {platform.system()} {platform.machine()})"
+    )
+    ctx.exit()
+
+
+class _HiddenHelpCommand(click.Command):
+    """A Click Command that hides the built-in --help from the options list."""
+
+    def get_params(self, ctx: click.Context) -> list:
+        params = super().get_params(ctx)
+        for p in params:
+            if isinstance(p, click.Option) and p.name == "help":
+                p.hidden = True
+        return params
+
+
+class _HiddenHelpGroup(click.Group):
+    """A Click Group whose subcommands all use HiddenHelpCommand."""
+    command_class = _HiddenHelpCommand
+
+
+@click.group(cls=_HiddenHelpGroup, add_help_option=False)
+@click.option(
+    "--help",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    hidden=True,
+    callback=lambda ctx, param, value: (click.echo(ctx.get_help(), color=ctx.color) or ctx.exit()) if value else None,
+)
+@click.option(
+    "--version",
+    is_flag=True,
+    callback=print_version,
+    expose_value=False,
+    is_eager=True,
+    help="Check DockerBrain version.",
+)
+def cli() -> None:
+    pass
+
+# Commands
+@cli.command()
+@click.option("--interval", "-i", default=1, show_default=True, help="Polling interval in seconds.")
+@click.option("--duration", "-d", default=None, type=int, help="Total seconds to monitor (default: unlimited).")
+def monitor(interval: int, duration: int | None) -> None:
+    """Display containers' stats."""
+    from core.monitor import run_monitor
+    run_monitor(interval=interval, duration=duration)
+
+@cli.command("suggest")
+@click.option("--container", "-c", default=None, help="Target a specific container (default: all).")
+@click.option("--window", "-w", default=30, show_default=True, help="Minutes of metric history to include.")
+@click.option("--dockerfile", "-f", default=None, type=click.Path(exists=True), help="Analyze a Dockerfile instead of containers.")
+@click.option("--no-rules", is_flag=True, default=False, help="Skip rule-based suggestions, send raw metrics only.")
+def ai_suggest(container: str | None, window: int, dockerfile: str | None, no_rules: bool) -> None:
+    """Get optimization suggestions for Dockerfiles and containers.
+
+    Two modes:
+
+    \b
+      1. Container mode (default):
+         Collects metrics from the last --window minutes and asks LLM
+         for optimizations.
+      2. Dockerfile mode (--dockerfile PATH):
+         Reads the Dockerfile and asks LLM to suggest overall improvements.
+
+    Requires an API key set in .dockerbrainrc.
+    """
+    from core.ai_advisor import run_ai_suggest
+
+    run_ai_suggest(
+        container_name=container,
+        window_minutes=window,
+        dockerfile_path=dockerfile,
+        no_rules=no_rules,
+    )
+
+@cli.command()
+@click.option("--dockerfile", "-f", default=None, type=click.Path(exists=True),
+              help="Path to a Dockerfile to auto-fix.")
+@click.option("--container", "-c", default=None,
+              help="Target a specific container (default: all).")
+def fix(dockerfile: str | None, container: str | None) -> None:
+    """Automatically diagnose and fix Docker issues.
+
+    \b
+    Two modes:
+      1. Dockerfile mode (--dockerfile PATH):
+         Detects anti-patterns, issues of Dockerfile,
+         and overwrites with a .bak backup on confirmation.
+      2. Container mode (default):
+         Runs analysis, asks LLM for improvements,
+         and executes with your confirmation.
+
+    Requires an API key set in .dockerbrainrc.
+    """
+    from core.fixer import run_fix
+
+    run_fix(dockerfile_path=dockerfile, container_name=container)
+
+@cli.command()
+@click.option("--force", is_flag=True, default=False,
+              help="Overwrite existing Dockerfile and .dockerignore forcefully.")
+def dockerize(force: bool) -> None:
+    """Generate a Dockerfile and .dockerignore for your project.
+
+    \b
+    Examples:
+      dockerb dockerize                  # Generate a Dockerfile and .dockerignore for your project
+      dockerb dockerize --force          # Overwrite existing Dockerfile forcefully
+
+    Requires an API key set in .dockerbrainrc.
+    """
+    from core.dockerizer import run_dockerize
+
+    run_dockerize(project_path=".", force=force)
+
+class _NoHelpOptGroup(click.Group):
+    """Group that hides the --help option from the help output."""
+    def get_help_option(self, ctx: click.Context) -> click.Option | None:
+        opt = super().get_help_option(ctx)
+        if opt:
+            opt.hidden = True
+        return opt
+
+@cli.group(cls=_NoHelpOptGroup)
+def template() -> None:
+    """Browse and use curated Dockerfile templates."""
+
+@template.command("list")
+def template_list() -> None:
+    """Show all available Dockerfile templates."""
+    from rich.console import Console
+    from rich.table import Table
+
+    from core.templates import TEMPLATES
+
+    console = Console()
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        border_style="dim",
+        expand=False,
+    )
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Template", style="bold green", no_wrap=True)
+    table.add_column("Stack")
+    table.add_column("Description")
+
+    for i, (key, tpl) in enumerate(sorted(TEMPLATES.items()), 1):
+        table.add_row(str(i), key, tpl["name"], tpl["description"])
+
+    console.print()
+    console.print(table)
+    console.print(
+        "\n[dim]Use a template:[/] [cyan]dockerb template use <name>[/]\n"
+    )
+
+@template.command("use")
+@click.argument("name")
+@click.option("--force", "-f", is_flag=True, help="Overwrite existing Dockerfile.")
+def template_use(name: str, force: bool) -> None:
+    """Generate a Dockerfile from a template.
+
+    \b
+    Examples:
+      dockerb template use fastapi
+      dockerb template use nextjs --force
+      dockerb template use go
+    """
+    from pathlib import Path
+
+    from rich.console import Console
+    from rich.syntax import Syntax
+
+    from core.templates import get_template, get_template_names
+
+    console = Console()
+    tpl = get_template(name)
+
+    if tpl is None:
+        console.print(f"[red]Unknown template:[/] [bold]{name}[/]")
+        console.print(
+            f"[dim]Available: {', '.join(get_template_names())}[/]"
+        )
+        return
+
+    dockerfile_path = Path("Dockerfile")
+
+    if dockerfile_path.exists() and not force:
+        from rich.prompt import Confirm
+        if not Confirm.ask(
+            "[yellow]Dockerfile already exists.[/] Overwrite?",
+            default=False,
+        ):
+            console.print("[dim]Skipped. No changes made.[/]")
+            return
+
+    dockerfile_path.write_text(tpl["dockerfile"], encoding="utf-8")
+    console.print(
+        f"[green]Created Dockerfile[/] [dim]({tpl['name']})[/]"
+    )
+
+    dockerignore_path = Path(".dockerignore")
+    if not dockerignore_path.exists():
+        dockerignore_content = """\
+.git
+.gitignore
+node_modules
+__pycache__
+*.pyc
+.env
+.venv
+.dockerignore
+Dockerfile
+README.md
+.idea
+.vscode
+"""
+        dockerignore_path.write_text(dockerignore_content, encoding="utf-8")
+        console.print("[green]Created .dockerignore[/]")
+
+    console.print()
+    console.print(Syntax(tpl["dockerfile"], "dockerfile", theme="monokai", line_numbers=True))
+
+
+@cli.command()
+def init() -> None:
+    """Create a .dockerbrainrc config file in the current directory.
+
+    Creates a TOML config with defaults for monitoring thresholds,
+    LLM model selection, and other settings. Edit it as per your requirements.
+    """
+    from pathlib import Path
+
+    from rich.console import Console
+
+    console = Console()
+    config_path = Path(".dockerbrainrc")
+
+    if config_path.exists():
+        console.print(f"[yellow] {config_path} already exists.[/]")
+        return
+
+    config_content = '''\
+# DockerBrain Configuration
+
+# LLM Provider & Models, To switch provider or model, edit below.
+
+# GEMINI (Overall Best)
+#   provider = "gemini"
+#   model = "gemini-3.1-flash-lite-preview", "gemini-flash-latest"
+
+# GROQ (Fast)
+#   provider = "groq"
+#   model = "openai/gpt-oss-120b", "llama-3.3-70b-versatile"   
+
+# OLLAMA (Local and Free)
+#   provider = "ollama"
+#   model = "llama3.1", "codestral", "qwen2.5-coder" (Or any other model)
+#   base_url = "http://localhost:11434/v1"   # change if not default
+
+[llm]
+provider = "gemini"
+model    = "gemini-3.1-flash-lite-preview"
+api_key  = ""              # Paste your LLM API key here
+# base_url = ""            # Only for Ollama
+
+[monitor]
+interval             = 5    # Polling interval in seconds
+alert_memory_pct     = 80   # Memory % threshold for warnings
+alert_cpu_idle       = 0.5  # CPU % below which a container is "idle"
+idle_consecutive_polls = 10 # Consecutive idle polls before flagging
+
+
+[optimize]
+check_secrets         = true  # Scan for hardcoded secrets in ENV
+check_base_image      = true  # Flag large base images
+check_apt_recommends  = true  # Flag apt-get without --no-install-recommends
+check_cache_busting   = true  # Flag COPY . . before dependency install
+check_dockerignore    = true  # Warn if .dockerignore is missing
+'''
+
+    config_path.write_text(config_content, encoding="utf-8")
+    console.print(f"[green]Created [bold]{config_path}[/bold][/]")
+
+@cli.command()
+def env() -> None:
+    """Check your environment and configs."""
+    import sqlite3
+    from pathlib import Path
+
+    import docker
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+
+    console = Console()
+    lines = Text()
+    all_ok = True
+
+    def _ok(label: str, detail: str) -> None:
+        lines.append(f"  {label:<20}", style="bold")
+        lines.append(f"{detail}\n")
+
+    def _fail(label: str, detail: str) -> None:
+        nonlocal all_ok
+        all_ok = False
+        lines.append(f"  {label:<20}", style="bold red")
+        lines.append(f"{detail}\n")
+
+    try:
+        client = docker.from_env()
+        info = client.version()
+        _ok("Docker daemon", f"running (v{info.get('Version', '?')})")
+    except Exception :
+        _fail("Docker daemon", f"not reachable")
+
+    try:
+        _ok("Docker SDK", f"docker-py {docker.__version__}")
+    except ImportError:
+        _fail("Docker SDK", "not installed → run: pip install docker")
+
+    try:
+        from core.llm import load_llm_config
+        cfg = load_llm_config()
+        _ok("LLM Provider", cfg.provider)
+        _ok("LLM Model", cfg.model)
+        masked = cfg.api_key[:4] + "…" + cfg.api_key[-4:] if len(cfg.api_key) > 8 else "set ✓"
+        _ok("API Key", f"{masked}")
+    except SystemExit:
+        _fail("API Key", "not set in .dockerbrainrc")
+
+    db_path = Path.home() / ".dockerbrain" / "metrics.db"
+    if db_path.exists():
+        size_kb = db_path.stat().st_size / 1024
+        try:
+            conn = sqlite3.connect(str(db_path))
+            row_count = conn.execute("SELECT COUNT(*) FROM container_metrics").fetchone()[0]
+            conn.close()
+            _ok("SQLite DB", f"{db_path} ({size_kb:.0f} KB, {row_count:,} rows)")
+        except Exception:
+            _ok("SQLite DB", f"{db_path} ({size_kb:.0f} KB)")
+    else:
+        _fail("SQLite DB", f"not found at {db_path} — run: dockerb monitor")
+
+    status = "[bold green]All checks passed!" if all_ok else "[bold yellow]Some checks failed"
+    console.print(
+        Panel(
+            lines,
+            title="[bold cyan] Environment Check[/]",
+            subtitle=status,
+            border_style="cyan",
+            expand=False,
+            padding=(1, 2),
+        )
+    )
+    raise SystemExit(0 if all_ok else 1)

core/dockerizer.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from rich.columns import Columns
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.syntax import Syntax
+from rich.table import Table
+
+from core.llm import load_llm_config, generate, LLMConfig
+
+console = Console()
+
+_LANGUAGE_SIGNATURES: dict[str, list[str]] = {
+    "Python":       ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile", "setup.cfg", "poetry.lock"],
+    "Node.js":      ["package.json", "yarn.lock", "pnpm-lock.yaml", "package-lock.json"],
+    "TypeScript":   ["tsconfig.json"],
+    "Deno":         ["deno.json", "deno.jsonc"],
+    "Go":           ["go.mod", "go.sum"],
+    "Rust":         ["Cargo.toml", "Cargo.lock"],
+    "Java/Kotlin":  ["pom.xml", "build.gradle", "build.gradle.kts", "gradlew"],
+    "Scala":        ["build.sbt"],
+    "Ruby":         ["Gemfile", "Gemfile.lock"],
+    "PHP":          ["composer.json", "composer.lock"],
+    "C#/.NET":      ["*.csproj", "*.sln", "Program.cs"],
+    "F#":           ["*.fsproj"],
+    "C/C++":        ["CMakeLists.txt", "*.c", "*.cpp", "configure.ac", "meson.build"],
+    "Swift":        ["Package.swift"],
+    "Dart/Flutter": ["pubspec.yaml"],
+    "Elixir":       ["mix.exs"],
+    "Erlang":       ["rebar.config", "rebar.lock"],
+    "Haskell":      ["stack.yaml", "*.cabal"],
+    "Clojure":      ["project.clj", "deps.edn"],
+    "Perl":         ["cpanfile", "Makefile.PL"],
+    "R":            ["DESCRIPTION", "*.Rproj"],
+    "Lua":          ["*.rockspec"],
+    "Crystal":      ["shard.yml"],
+    "Static/HTML":  ["index.html"],
+}
+
+_SKIP_DIRS = {
+    ".git", ".venv", "venv", "node_modules", "__pycache__", ".tox",
+    ".pytest_cache", ".mypy_cache", ".egg-info", "dist", "build",
+    ".idea", ".vscode", "target", "bin", "obj", ".next", ".nuxt",
+    ".dart_tool", ".pub-cache", "_build", "deps", "vendor",
+    ".stack-work", "elm-stuff", "zig-cache",
+}
+
+_SKIP_EXTENSIONS = {
+    ".pyc", ".pyo", ".exe", ".dll", ".so", ".dylib", ".o",
+    ".class", ".jar", ".war", ".db", ".sqlite", ".sqlite3",
+    ".lock", ".log", ".bak", ".swp", ".swo",
+}
+
+_DOCKERIZE_SYSTEM = (
+    "You are a world-class Docker expert. Given a project's directory structure and key config "
+    "file contents, generate a production-ready Dockerfile.\n\n"
+    "CRITICAL RULES:\n"
+    "1. Return ONLY a valid JSON object with exactly two keys:\n"
+    '   - "dockerfile": the full Dockerfile content as a string\n'
+    '   - "dockerignore": the full .dockerignore content as a string\n'
+    "2. No markdown, no code fences, no explanation — ONLY the raw JSON object.\n"
+    "3. Use multi-stage builds where appropriate (especially for compiled languages).\n"
+    "4. Always use slim or alpine base images.\n"
+    "5. Install dependencies BEFORE copying source code (layer caching).\n"
+    "6. Chain RUN commands with && to minimize layers.\n"
+    "7. Clean up package manager caches (apt, apk, pip, npm).\n"
+    "8. Add a non-root USER for security.\n"
+    "9. Add a HEALTHCHECK if a web server or API is detected.\n"
+    "10. Use exec-form CMD (JSON array).\n"
+    "11. Pin base image versions (e.g., python:3.12-slim, not python:latest).\n"
+    "12. Add brief comments in the Dockerfile explaining each stage/step.\n"
+    "13. The .dockerignore should exclude: .git, .venv, venv, node_modules, __pycache__, "
+    "*.pyc, .env, .idea, .vscode, *.md, dist, build, tests, .pytest_cache, .mypy_cache, "
+    "and any other development-only files detected in the project.\n"
+)
+
+def _scan_project(project_dir: Path) -> dict:
+    """Scan the project directory and return structured info for the AI prompt."""
+
+    tree_lines: list[str] = []
+
+    def _walk(current: Path, prefix: str, depth: int) -> None:
+        if depth > 3:
+            return
+        try:
+            entries = sorted(current.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+        except PermissionError:
+            return
+
+        dirs = [e for e in entries if e.is_dir() and e.name not in _SKIP_DIRS and not e.name.startswith(".")]
+        files = [e for e in entries if e.is_file() and e.suffix not in _SKIP_EXTENSIONS]
+
+        for f in files:
+            tree_lines.append(f"{prefix}{f.name}")
+        for d in dirs:
+            tree_lines.append(f"{prefix}{d.name}/")
+            _walk(d, prefix + "  ", depth + 1)
+
+    _walk(project_dir, "", 0)
+
+    # Detect language
+    detected_languages: list[str] = []
+    for language, signatures in _LANGUAGE_SIGNATURES.items():
+        for sig in signatures:
+            if "*" in sig:
+                # Glob pattern
+                if list(project_dir.glob(sig)):
+                    detected_languages.append(language)
+                    break
+            elif (project_dir / sig).exists():
+                detected_languages.append(language)
+                break
+
+    # Read key config files 
+    key_files_content: dict[str, str] = {}
+    priority_files = [
+        "requirements.txt", "pyproject.toml", "setup.py", "Pipfile",
+        "package.json", "tsconfig.json", "deno.json",
+        "go.mod", "Cargo.toml", "pom.xml",
+        "build.gradle", "build.sbt",
+        "Gemfile", "composer.json", "mix.exs",
+        "CMakeLists.txt", "Package.swift", "pubspec.yaml",
+        "stack.yaml", "project.clj", "deps.edn",
+        "rebar.config", "shard.yml", "cpanfile",
+        "Makefile", "Procfile", "app.json", "runtime.txt",
+    ]
+
+    collected = 0
+    for fname in priority_files:
+        fpath = project_dir / fname
+        if fpath.exists() and collected < 5:
+            try:
+                lines = fpath.read_text(encoding="utf-8", errors="replace").splitlines()[:200]
+                key_files_content[fname] = "\n".join(lines)
+                collected += 1
+            except Exception:
+                pass
+
+    has_dockerfile = (project_dir / "Dockerfile").exists()
+    has_dockerignore = (project_dir / ".dockerignore").exists()
+
+    return {
+        "tree": "\n".join(tree_lines[:150]), 
+        "detected_languages": detected_languages,
+        "key_files": key_files_content,
+        "has_dockerfile": has_dockerfile,
+        "has_dockerignore": has_dockerignore,
+    }
+
+
+def _display_scan_results(scan: dict) -> None:
+    """Show the user what was detected before generating."""
+
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        border_style="bright_blue",
+        expand=False,
+    )
+    table.add_column("Property", style="bold", no_wrap=True)
+    table.add_column("Value", style="white")
+
+    languages = ", ".join(scan["detected_languages"]) if scan["detected_languages"] else "Unknown"
+    table.add_row("Detected Language", f"[green]{languages}[/]")
+    table.add_row("Configs", ", ".join(scan["key_files"].keys()) or "None")
+    table.add_row("Dockerfile", "[yellow]Yes[/]" if scan["has_dockerfile"] else "[dim]No[/]")
+    table.add_row(".dockerignore", "[yellow]Yes[/]" if scan["has_dockerignore"] else "[dim]No[/]")
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+def _generate_via_ai(scan: dict, config: LLMConfig) -> dict:
+    """Send project info to the configured LLM and get back Dockerfile + .dockerignore."""
+
+    # Build the prompt
+    parts = ["## Project Analysis\n"]
+
+    if scan["detected_languages"]:
+        parts.append(f"**Detected language(s):** {', '.join(scan['detected_languages'])}\n")
+
+    parts.append(f"### Directory Structure\n```\n{scan['tree']}\n```\n")
+
+    for fname, content in scan["key_files"].items():
+        parts.append(f"### {fname}\n```\n{content}\n```\n")
+
+    parts.append("\nGenerate an optimized Dockerfile and .dockerignore for this project.")
+
+    prompt = "\n".join(parts)
+
+    with console.status("[bold green]Generating Dockerfile...[/]", spinner="dots"):
+        raw = generate(
+            prompt=prompt,
+            system_instruction=_DOCKERIZE_SYSTEM,
+            config=config,
+        )
+
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        console.print(
+            Panel(
+                f"[red]Could not parse LLM response as JSON.[/]\n\n[dim]{raw[:500]}[/]",
+                title="[bold red]Parse Error[/]",
+                border_style="red",
+                expand=False,
+            )
+        )
+        return {}
+
+def _preview_files(dockerfile: str, dockerignore: str) -> None:
+    """Show side-by-side preview of the generated files."""
+
+    left = Panel(
+        Syntax(dockerfile, "dockerfile", theme="monokai", line_numbers=True, word_wrap=True),
+        title="[bold cyan]Dockerfile[/]",
+        border_style="cyan",
+        expand=True,
+    )
+    right = Panel(
+        Syntax(dockerignore, "ini", theme="monokai", line_numbers=True, word_wrap=True),
+        title="[bold cyan].dockerignore[/]",
+        border_style="cyan",
+        expand=True,
+    )
+    console.print()
+    console.print(Columns([left, right], equal=True, expand=True))
+
+def run_dockerize(project_path: str, force: bool = False) -> None:
+    """Scan a project directory and generate a Dockerfile + .dockerignore via AI."""
+
+    project_dir = Path(project_path).resolve()
+
+    if not project_dir.is_dir():
+        console.print(f"[red]Not a directory: {project_dir}[/]")
+        raise SystemExit(1)
+
+    console.print(
+        Panel(
+            f"[bold]Scanning:[/] [cyan]{project_dir}[/]",
+            border_style="cyan",
+            expand=False,
+        )
+    )
+
+    scan = _scan_project(project_dir)
+
+    if not scan["detected_languages"]:
+        console.print(
+            "[yellow]Could not auto-detect the project language. "
+            "Attempt to generate a Dockerfile based on the directory structure.[/]\n"
+        )
+
+    _display_scan_results(scan)
+
+    # Check for existing files
+    dockerfile_path = project_dir / "Dockerfile"
+    dockerignore_path = project_dir / ".dockerignore"
+
+    if not force:
+        if dockerfile_path.exists():
+            if not Confirm.ask(
+                f"[yellow]Dockerfile already exists at [cyan]{dockerfile_path}[/cyan]. Overwrite?[/]",
+                default=False,
+            ):
+                console.print("[dim]Aborted.[/]")
+                return
+
+    config = load_llm_config()
+    result = _generate_via_ai(scan, config)
+
+    if not result:
+        return
+
+    dockerfile_content = result.get("dockerfile", "")
+    dockerignore_content = result.get("dockerignore", "")
+
+    if not dockerfile_content:
+        console.print("[red]Returned an empty Dockerfile.[/]")
+        return
+
+    # Preview
+    _preview_files(dockerfile_content, dockerignore_content)
+
+    console.print()
+    if not Confirm.ask("[bold]Write these files?[/]", default=True):
+        console.print("[dim]Aborted. No files written.[/]")
+        return
+
+    dockerfile_path.write_text(dockerfile_content + "\n", encoding="utf-8")
+    console.print(f"[green bold]Created:[/] [cyan]{dockerfile_path}[/]")
+
+    if dockerignore_content:
+        if dockerignore_path.exists() and not force:
+            if Confirm.ask(
+                f"[yellow].dockerignore already exists. Overwrite?[/]",
+                default=False,
+            ):
+                dockerignore_path.write_text(dockerignore_content + "\n", encoding="utf-8")
+                console.print(f"[green bold]Created:[/] [cyan]{dockerignore_path}[/]")
+            else:
+                console.print("[dim]Skipped .dockerignore.[/]")
+        else:
+            dockerignore_path.write_text(dockerignore_content + "\n", encoding="utf-8")
+            console.print(f"[green bold]Created:[/] [cyan]{dockerignore_path}[/]")

core/fixer/__init__.py

@@ -0,0 +1,21 @@
+from core.fixer.dockerfile import fix_dockerfile
+from core.fixer.container import fix_containers, _is_safe_command
+
+
+def run_fix(
+    dockerfile_path: str | None = None,
+    container_name: str | None = None,
+) -> None:
+    """Route to dockerfile or container fix mode."""
+    if dockerfile_path:
+        fix_dockerfile(dockerfile_path)
+    else:
+        fix_containers(container_name)
+
+
+__all__ = [
+    "run_fix",
+    "fix_dockerfile",
+    "fix_containers",
+    "_is_safe_command",
+]