dblift 2.0.3__tar.gz → 2.0.4__tar.gz

{dblift-2.0.3 → dblift-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 2.0.3
+Version: 2.0.4
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -22,6 +22,7 @@ Requires-Dist: Jinja2>=3.1.0
 Requires-Dist: sqlglot>=30.0.0
 Requires-Dist: packaging>=23.0
 Requires-Dist: azure-cosmos>=4.5.0
+Requires-Dist: azure-identity>=1.15.0
 Requires-Dist: SQLAlchemy>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.3.1; extra == "dev"
@@ -132,6 +133,30 @@ DBLift helps you track and apply database changes systematically. Think of it as
 <!-- BEGIN: OSS README sync: python-install -->
 #### Python / pip install
 
+| Install | Dialects |
+| --- | --- |
+| `pip install dblift[postgresql]` | PostgreSQL (OSS) |
+| `pip install dblift[oracle]` | Oracle (OSS) |
+
+`pytest-dblift` quickstart:
+
+```bash
+pip install pytest-dblift
+```
+
+```python
+# tests/test_foo.py
+import pytest
+
+def test_something(dblift_migrated_db, dblift_client):
+    # dblift_migrated_db ensures migrations applied (function scope by default)
+    result = dblift_client.info()
+    assert result.pending_count == 0
+```
+<!-- END: OSS README sync: python-install -->
+
+#### Using the Python SDK
+
 **Synchronous client:**
 
 ```python
@@ -157,28 +182,6 @@ async with AsyncDBLiftClient.from_sqlalchemy(engine, migrations_dir="migrations"
 
 See [Async usage](docs/user-guide/async.md) for the full guide.
 
-| Install | Dialects |
-| --- | --- |
-| `pip install dblift[postgresql]` | PostgreSQL (OSS) |
-| `pip install dblift[oracle]` | Oracle (OSS) |
-
-`pytest-dblift` quickstart:
-
-```bash
-pip install pytest-dblift
-```
-
-```python
-# tests/test_foo.py
-import pytest
-
-def test_something(dblift_migrated_db, dblift_client):
-    # dblift_migrated_db ensures migrations applied (function scope by default)
-    result = dblift_client.info()
-    assert result.pending_count == 0
-```
-<!-- END: OSS README sync: python-install -->
-
 ### Your First Migration
 
 Let's create your first database change in 4 simple steps:

{dblift-2.0.3 → dblift-2.0.4}/README.md

@@ -53,6 +53,30 @@ DBLift helps you track and apply database changes systematically. Think of it as
 <!-- BEGIN: OSS README sync: python-install -->
 #### Python / pip install
 
+| Install | Dialects |
+| --- | --- |
+| `pip install dblift[postgresql]` | PostgreSQL (OSS) |
+| `pip install dblift[oracle]` | Oracle (OSS) |
+
+`pytest-dblift` quickstart:
+
+```bash
+pip install pytest-dblift
+```
+
+```python
+# tests/test_foo.py
+import pytest
+
+def test_something(dblift_migrated_db, dblift_client):
+    # dblift_migrated_db ensures migrations applied (function scope by default)
+    result = dblift_client.info()
+    assert result.pending_count == 0
+```
+<!-- END: OSS README sync: python-install -->
+
+#### Using the Python SDK
+
 **Synchronous client:**
 
 ```python
@@ -78,28 +102,6 @@ async with AsyncDBLiftClient.from_sqlalchemy(engine, migrations_dir="migrations"
 
 See [Async usage](docs/user-guide/async.md) for the full guide.
 
-| Install | Dialects |
-| --- | --- |
-| `pip install dblift[postgresql]` | PostgreSQL (OSS) |
-| `pip install dblift[oracle]` | Oracle (OSS) |
-
-`pytest-dblift` quickstart:
-
-```bash
-pip install pytest-dblift
-```
-
-```python
-# tests/test_foo.py
-import pytest
-
-def test_something(dblift_migrated_db, dblift_client):
-    # dblift_migrated_db ensures migrations applied (function scope by default)
-    result = dblift_client.info()
-    assert result.pending_count == 0
-```
-<!-- END: OSS README sync: python-install -->
-
 ### Your First Migration
 
 Let's create your first database change in 4 simple steps:

{dblift-2.0.3 → dblift-2.0.4}/api/client.py

@@ -59,8 +59,7 @@ def _with_client_emitter(method: _F) -> _F:
     "every public operation wraps its body in ``use_client_emitter``",
     but only ``migrate`` and ``undo`` actually did. Any core-layer
     ``emit_event`` raised from ``clean`` / ``info`` / ``validate`` /
-    ``diff`` / ``repair`` / ``baseline`` / ``import_flyway`` /
-    ``export_schema`` / ``snapshot`` would land on the process-wide
+    ``repair`` / ``baseline`` / ``import_flyway`` would land on the process-wide
     default emitter, breaking the per-client isolation guarantee.
     Decorating every public operation restores that invariant once and
     keeps it enforced by location instead of by convention.

{dblift-2.0.3 → dblift-2.0.4}/cli/_command_handlers.py

@@ -9,7 +9,6 @@ from cli.extensions import load_command_handlers, load_terminal_commands
 from cli.handlers._shared import (  # noqa: F401
     _MIGRATION_FILENAME_RE,
     CliCommandContext,
-    ValidateSqlConfigClient,
     _extract_version_filters,
     _is_migration_sql_file,
     _minimal_result,

{dblift-2.0.3 → dblift-2.0.4}/cli/_config_helpers.py

@@ -224,22 +224,16 @@ def _load_and_merge_config(args: argparse.Namespace, log: Any) -> Any:
         db_overrides["schema"] = args.database_schema
 
     if db_overrides:
-        # Resolve secret URIs in CLI overrides, but only for online commands.
-        # Offline commands (plan, validate-sql) skip secret resolution in load_config;
-        # the same bypass must apply here so they don't trigger provider calls.
-        command = getattr(args, "command", None)
-        commands_list = getattr(args, "commands_list", None) or ([command] if command else [])
-        is_offline = command in ("validate-sql", "plan") and len(commands_list) == 1
-        if not is_offline:
-            from config.secrets._resolver import resolve_secret_refs
+        # Resolve secret URIs in CLI overrides.
+        from config.secrets._resolver import resolve_secret_refs
 
-            try:
-                db_overrides = resolve_secret_refs({"database": db_overrides}, config.secrets).get(
-                    "database", db_overrides
-                )
-            except SecretsResolutionError as e:
-                print(f"Error: {e}", file=sys.stderr)
-                sys.exit(1)
+        try:
+            db_overrides = resolve_secret_refs({"database": db_overrides}, config.secrets).get(
+                "database", db_overrides
+            )
+        except SecretsResolutionError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
         config.database = ConfigBuilder.merge_database_overrides(config.database, db_overrides)
 
     if log:
@@ -300,12 +294,9 @@ def _validate_db_config(
         "clean",
         "validate",
         "info",
-        "diff",
         "repair",
         "import-flyway",
         "baseline",
-        "export-schema",
-        "snapshot",
     ]
     if args.command not in migration_commands:
         return

{dblift-2.0.3 → dblift-2.0.4}/cli/_constants.py

@@ -22,12 +22,3 @@ from __future__ import annotations
 MACHINE_READABLE_FORMATS: frozenset[str] = frozenset(
     {"json", "sarif", "github-actions", "gitlab", "compact"}
 )
-FAIL_ON_CHOICES: tuple[str, ...] = ("never", "error", "warning", "info")
-
-# ``console`` and ``html`` are human-facing; every other entry must also
-# appear in ``MACHINE_READABLE_FORMATS`` above (tested in the matrix
-# regression suite to prevent the two lists from drifting out of sync).
-VALIDATE_SQL_FORMATS: tuple[str, ...] = (
-    "console",
-    "html",
-) + tuple(sorted(MACHINE_READABLE_FORMATS))

{dblift-2.0.3 → dblift-2.0.4}/cli/_output.py

@@ -13,8 +13,7 @@ dispatch in ``cli/main.py`` re-derive the same predicate:
     else:
         ctx.log.info(payload)          # routed through ConsoleLog
 
-That duplication has already caused two regressions (PR 158 banner fix
-+ PR-01 `validate-sql --format json` scope). ADR-0005 added the
+That duplication has already caused banner-routing regressions. ADR-0005 added the
 `MACHINE_READABLE_FORMATS` set as a single source of truth; this
 module does the same for the *routing* decision itself.
 

{dblift-2.0.3 → dblift-2.0.4}/cli/handlers/_shared.py

@@ -12,9 +12,9 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-# Flyway-compatible migration filename patterns — used by validate-sql to
-# skip non-migration SQL files when scanning a directory (e.g. leftover
-# temp files, schema dumps) so only intentional migration scripts are
+# Flyway-compatible migration filename patterns used to skip non-migration
+# SQL files when scanning a directory (e.g. leftover temp files, schema
+# dumps) so only intentional migration scripts are
 # checked. Explicitly-listed files are always validated regardless of name.
 _MIGRATION_FILENAME_RE = re.compile(
     r"^[VRUBvrub][\d_.]*__.*\.sql$",
@@ -61,17 +61,6 @@ class CliCommandContext:
     dir_recursive_map: Dict[Path, bool] = field(default_factory=dict)
 
 
-@dataclass
-class ValidateSqlConfigClient:
-    """Config-only stand-in for DBLiftClient when running offline commands."""
-
-    config: Any
-
-    def plan(self, *args: Any, **kwargs: Any) -> Any:
-        """Offline plan construction is not available in DBLift OSS."""
-        raise RuntimeError("plan is not available in DBLift OSS")
-
-
 def _set_command_completed(log: Any, result: Any, command_type: str) -> None:
     """Helper to report command completion to the logger (eliminates SMELL-04 duplication)."""
     if result is None:
@@ -98,7 +87,7 @@ def emit_rendered_output(
 ) -> None:
     """Dispatch a rendered command output to machine channel, logger, and/or file.
 
-    Shared by plan and preflight handlers — both follow the same machine/human/file
+    Used by command handlers that follow the same machine/human/file
     dispatch pattern once the command-specific rendering is done.
     """
     if command_output.is_machine_format:

{dblift-2.0.3 → dblift-2.0.4}/cli/main.py

@@ -3,7 +3,7 @@
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional
 
 # Add project root to Python path when running as a script
 # This allows imports to work when running: python3 cli/main.py
@@ -23,7 +23,6 @@ from cli._command_handlers import (  # noqa: F401
     _AVAILABLE_COMMANDS,
     _COMMAND_HANDLERS,
     CliCommandContext,
-    ValidateSqlConfigClient,
     _extract_version_filters,
     _handle_baseline,
     _handle_clean,
@@ -233,8 +232,7 @@ def _parse_argv_and_load_config(argv: List[str]) -> _CliContext:
     # Validate log format before any config load so bogus --log-format fails with argparse
     # UX (and so db/* commands are covered — _validate_db_config skips early for "db").
     _validate_log_format_for_cli(args, parser)
-    # Attach the full command list so load_config can distinguish standalone
-    # offline commands (plan, validate-sql) from chained invocations.
+    # Attach the full command list so load_config can see chained invocations.
     args.commands_list = commands
     config = None if commands[0] == "db" else _load_and_merge_config(args, log)
     _validate_db_config(args, config, parser, commands)
@@ -289,24 +287,12 @@ def _setup_logging_and_output(ctx: _CliContext) -> CommandOutput:
     assert ctx.config is not None
     ctx.log = _configure_logging(ctx.args, ctx.config, ctx.parser)
 
-    _apply_validate_sql_configured_output_format(ctx)
-
     # Banner routing is centralised in :class:`cli._output.CommandOutput`
     # (ADR-0008 supersedes ADR-0005's suppression approach). Machine
     # mode routes the banner to stderr; human mode keeps it on stdout.
     return from_args(ctx.args)
 
 
-def _apply_validate_sql_configured_output_format(ctx: _CliContext) -> None:
-    """Use configured validate-sql output format before top-level banner routing."""
-    if ctx.commands != ["validate-sql"] or getattr(ctx.args, "format", None):
-        return
-    validation_config = getattr(ctx.config, "validation", None)
-    output_format = getattr(validation_config, "output_format", None)
-    if output_format:
-        ctx.args.format = output_format
-
-
 def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
     """Phase 4: build full workflow context and run the command loop.
 
@@ -319,13 +305,7 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
         _resolve_scripts_directories(ctx.args, ctx.config, ctx.parser, ctx.commands)
     )
 
-    # Standalone offline commands only need DbliftConfig (dialect, validation rules).
-    offline_only = False
-    client: Union[DBLiftClient, ValidateSqlConfigClient]
-    if offline_only:
-        client = ValidateSqlConfigClient(config=ctx.config)
-    else:
-        client = DBLiftClient.from_config(ctx.config, logger=ctx.log)
+    client = DBLiftClient.from_config(ctx.config, logger=ctx.log)
     ctx.log.debug(f"scripts_dir: {scripts_dir}")
     ctx.log.debug(
         f"config.migrations.directories: {getattr(ctx.config.migrations, 'directories', None)}"
@@ -364,13 +344,6 @@ def _dispatch_command(ctx: _CliContext, command_output: CommandOutput) -> int:
         # in base_command does not re-emit it (it also has no format awareness).
         if main_header:
             base_command._console_main_header_printed = True  # type: ignore[attr-defined]
-            for module_name in (
-                "cli.export_schema_command",
-                "cli.snapshot_command",
-            ):
-                command_module = sys.modules.get(module_name)
-                if command_module is not None:
-                    command_module._console_main_header_printed = True  # type: ignore[attr-defined]
 
         for cmd_index, command in enumerate(ctx.commands):
             if len(ctx.commands) > 1 and cmd_index > 0:

{dblift-2.0.3 → dblift-2.0.4}/config/dblift_config.py

@@ -10,7 +10,6 @@ import yaml
 from config.database_config import BaseDatabaseConfig
 from config.errors import ConfigurationError
 from config.secrets import SecretsConfig, resolve_secret_refs
-from config.validation_config import ValidationConfig
 
 ENV_PLACEHOLDER_PATTERN = re.compile(r"\$\{([^}:]+)(?::-(.*?))?\}")
 
@@ -28,56 +27,6 @@ _CONFIG_LOAD_EXC: Tuple[Type[Exception], ...] = (
 )
 
 
-# ``validate-sql`` only needs a dialect-typed DbliftConfig; connection is never opened.
-# Placeholder database URLs satisfy :meth:`DbliftConfig.validate_complete_data` and are never
-# used to connect in the validate-sql code path.
-def _validate_sql_lint_filler(dialect: str) -> Dict[str, Any]:
-    """Minimal ``database:`` block for validate-sql (lint-only) when
-    no real DB is configured.
-
-    Story 26-11: dialect normalisation + placeholder URL come from the
-    plugin registry / quirks. The earlier hardcoded
-    ``_VALIDATE_SQL_DIALECT_TO_DB``, ``_VALIDATE_SQL_PLACEHOLDER_URL``,
-    and ``_VALIDATE_SQL_DB_TO_DIALECT`` dicts are gone; adding a new
-    dialect with offline-lint support = override
-    ``lint_placeholder_url`` in its plugin quirks.py.
-    """
-    from db.provider_registry import ProviderRegistry
-
-    db_type = ProviderRegistry.canonical_dialect_name((dialect or "").strip().lower())
-    if not db_type:
-        return {}
-    quirks = ProviderRegistry.get_quirks(db_type)
-    placeholder = quirks.lint_placeholder_url
-    if not placeholder:
-        return {}
-    return {
-        "database": {
-            "type": db_type,
-            "url": placeholder,
-            "username": "dblift_validate_sql",
-            "password": "dblift_validate_sql",
-        }
-    }
-
-
-def _validate_sql_effective_dialect(args: Any, config_data: Dict[str, Any]) -> Optional[str]:
-    """Resolve validate-sql dialect from CLI or config without defaulting."""
-    cli_dialect = getattr(args, "dialect", None)
-    if isinstance(cli_dialect, str) and cli_dialect.strip():
-        return cli_dialect.strip().lower()
-
-    database_config = config_data.get("database")
-    if isinstance(database_config, dict):
-        from db.provider_registry import ProviderRegistry
-
-        db_type = str(database_config.get("type") or "").strip().lower()
-        if db_type:
-            return ProviderRegistry.canonical_dialect_name(db_type) or db_type
-
-    return None
-
-
 def _placeholder_tokens(raw_placeholders: Any) -> List[str]:
     if not raw_placeholders:
         return []
@@ -170,30 +119,12 @@ def load_config(config_file_path: Optional[str], args: Optional[Any] = None) ->
         if args_dict:
             config_data = DbliftConfig.merge_config_data(config_data, args_dict)
 
-    # ``validate-sql`` does not need a real database, but static linting does
-    # need an explicit SQL dialect or a database type from config.
-    if args and getattr(args, "command", None) == "validate-sql":
-        dialect = _validate_sql_effective_dialect(args, config_data)
-        if not dialect:
-            raise ConfigurationError(
-                "validate-sql requires --dialect for offline validation when no database type is configured."
-            )
-        filler = _validate_sql_lint_filler(dialect)
-        if filler:
-            config_data = DbliftConfig.merge_config_data(filler, config_data)
-
     if not config_data:
         raise ConfigurationError(
             "No configuration source provided. Pass --config, --db-url, or set DBLIFT_DB_URL."
         )
 
-    command = getattr(args, "command", None) if args else None
-    commands_list = getattr(args, "commands_list", None) if args else None
-    if commands_list is None and command:
-        commands_list = [command]
-    is_offline_cmd = bool(
-        command in ("validate-sql", "plan") and commands_list and len(commands_list) == 1
-    )
+    is_offline_cmd = False
     config = DbliftConfig.from_dict(config_data, resolve_secrets=not is_offline_cmd)
     if args:
         installed_by = getattr(args, "installed_by", None)
@@ -322,7 +253,6 @@ class DbliftConfig:
     database: BaseDatabaseConfig
     migrations: MigrationsConfig = field(default_factory=MigrationsConfig)
     logging: LoggingConfig = field(default_factory=LoggingConfig)
-    validation: ValidationConfig = field(default_factory=ValidationConfig)
     baseline_version: Optional[str] = None
     target_version: Optional[str] = None
     dry_run: bool = False
@@ -455,11 +385,6 @@ class DbliftConfig:
         if "log_dir" in other_config:
             self.log_dir = other_config.get("log_dir", self.log_dir)
 
-        if "validation" in other_config:
-            raw_val = other_config["validation"]
-            if raw_val is not None and isinstance(raw_val, dict):
-                self.validation = ValidationConfig.from_dict(raw_val)
-
         # Fields that must use ``key in other_config`` so falsy values (False, 0) are not dropped.
         for scalar_key in (
             "strict_mode",
@@ -507,8 +432,8 @@ class DbliftConfig:
         Args:
             data: Configuration dictionary
             resolve_secrets: When False, skip secret-URI resolution (used for
-                offline commands such as validate-sql that never open a DB connection
-                and must not require secret-manager credentials to be available).
+                offline commands that never open a DB connection and must not
+                require secret-manager credentials to be available).
 
         Returns:
             A DbliftConfig instance
@@ -562,7 +487,7 @@ class DbliftConfig:
                 # Non-secret unparseable URLs are left as-is so _apply_url_overrides
                 # raises a focused URL error immediately rather than producing a
                 # silently broken config.
-        # When secrets are not resolved (offline commands like plan/validate-sql),
+        # When secrets are not resolved (offline commands),
         # a secret URI in database.url must not be validated as a database URL — the
         # type may already be known from database.type but the URL is still raw.
         # This covers the case where database.type is set explicitly, which skips
@@ -663,7 +588,6 @@ class DbliftConfig:
                 detect_encoding=migrations_detect_encoding,
             ),
             logging=LoggingConfig(level=log_level, file=log_file, directory=log_directory),
-            validation=ValidationConfig.from_dict(data.get("validation", {})),
             baseline_version=data.get("baseline_version"),
             target_version=data.get("target_version"),
             dry_run=data.get("dry_run", False),

{dblift-2.0.3 → dblift-2.0.4}/core/logger/__init__.py

@@ -17,12 +17,10 @@ from core.logger.log import (
 from core.logger.results import (
     BaselineResult,
     CleanResult,
-    DiffResult,
     InfoResult,
     MigrateResult,
     MigrationInfo,
     OperationResult,
-    PlanResult,
     RepairResult,
     ValidateResult,
 )
@@ -428,7 +426,6 @@ __all__ = [
     "ConsoleLog",
     "MultiLog",
     "OperationResult",
-    "PlanResult",
     "MigrateResult",
     "MigrationInfo",
     "InfoResult",
@@ -438,7 +435,6 @@ __all__ = [
     "RepairResult",
     "NullLog",
     "DbliftLogger",
-    "DiffResult",
     # Formatters
     "OutputFormatter",
     "OutputFormatterFactory",

{dblift-2.0.3 → dblift-2.0.4}/core/logger/console.py

@@ -168,7 +168,7 @@ def console_status(message: str) -> "ContextManager[Any]":
     """Return a Rich ``Console.status`` context manager, or a no-op
     when progress is disabled (``--no-progress`` / non-tty).
 
-    Long-running command paths (snapshot, export-schema) wrap their
+    Long-running command paths wrap their
     blocking service calls with this so the spinner respects the
     same suppression rules as ``rich.progress.Progress``.
     """

{dblift-2.0.3 → dblift-2.0.4}/core/logger/formatters/_formatter_impl.py

@@ -13,18 +13,12 @@ This file was extracted from the monolithic
 from pathlib import Path
 from typing import Any, Dict, Optional, Type
 
-from core.logger.formatters._format_diff_meta import _DiffMetaFormatterMixin
-from core.logger.formatters._format_diff_object import _DiffObjectFormatterMixin
-from core.logger.formatters._format_diff_routine import _DiffRoutineFormatterMixin
-from core.logger.formatters._format_diff_table import _DiffTableFormatterMixin
 from core.logger.results import (
     BaselineResult,
     CleanResult,
-    DiffResult,
     InfoResult,
     MigrateResult,
     OperationResult,
-    PlanResult,
     RepairResult,
     UndoResult,
     ValidateResult,
@@ -42,12 +36,7 @@ except ImportError:
     JsonFormatter = None  # type: ignore
 
 
-class OutputFormatter(
-    _DiffMetaFormatterMixin,
-    _DiffTableFormatterMixin,
-    _DiffRoutineFormatterMixin,
-    _DiffObjectFormatterMixin,
-):
+class OutputFormatter:
     """Unified formatter for all operation results."""
 
     # Maps result type → (format_method_name, command_type_string)
@@ -58,9 +47,7 @@ class OutputFormatter(
         ValidateResult: ("format_validate", "validate"),
         BaselineResult: ("format_baseline", "baseline"),
         RepairResult: ("format_repair", "repair"),
-        DiffResult: ("format_diff", "diff"),
         UndoResult: ("format_undo", "undo"),
-        PlanResult: ("format_plan", "plan"),
     }
 
     def __init__(self) -> None:
@@ -192,55 +179,6 @@ class OutputFormatter(
         self._append_sql_visibility(output, result)
         return "\n".join(output)
 
-    def format_plan(self, result: PlanResult) -> str:
-        """Format an offline plan operation result."""
-        output = []
-        output.append("Migration Plan Report")
-        output.append("=====================")
-        output.append(f"Snapshot: {result.snapshot_model or ''}")
-        output.append("Status: SUCCESS" if result.success else "Status: FAILED")
-        if result.error_message:
-            output.append(f"Error: {result.error_message}")
-        output.append(f"Applied in snapshot: {result.already_applied_count}")
-        output.append(f"Pending versioned: {result.pending_count}")
-        output.append(f"Pending repeatable: {result.repeatables_pending_count}")
-        output.append(f"Checksum drift: {result.checksum_drift_count}")
-        if result.sql_validation:
-            output.append(
-                "SQL validation: "
-                f"{result.sql_validation.status} "
-                f"({result.sql_validation.files_checked} files)"
-            )
-        if result.pending_migrations:
-            output.append("")
-            output.append("Pending Migrations:")
-            for migration in result.pending_migrations:
-                output.append(f"- {migration.script}")
-        if result.repeatables_pending:
-            output.append("")
-            output.append("Repeatables Pending:")
-            for migration in result.repeatables_pending:
-                output.append(f"- {migration.script}")
-        if result.checksum_drift:
-            output.append("")
-            output.append("Checksum Drift:")
-            for drift in result.checksum_drift:
-                output.append(
-                    f"- {drift.script}: snapshot={drift.expected_checksum}, "
-                    f"local={drift.actual_checksum}"
-                )
-        if result.plan_errors:
-            output.append("")
-            output.append("Errors:")
-            for error in result.plan_errors:
-                output.append(f"- {error}")
-        if result.plan_warnings:
-            output.append("")
-            output.append("Warnings:")
-            for warning in result.plan_warnings:
-                output.append(f"- {warning}")
-        return "\n".join(output)
-
     def _append_sql_visibility(self, output: list[str], result: OperationResult) -> None:
         """Append SQL statements only when the operation explicitly requested them."""
         if not getattr(result, "show_sql", False) or not getattr(result, "sql", None):
@@ -545,23 +483,3 @@ class OutputFormatter(
                 output.append(f"- {warning}")
 
         return "\n".join(output)
-
-    def format_diff(self, result: DiffResult) -> str:
-        """Format a diff/comparison operation result."""
-        sections = [
-            self._format_diff_header(result),
-            self._format_diff_counts(result),
-            self._format_table_diff(result),
-            self._format_view_diff(result),
-            self._format_index_diff(result),
-            self._format_sequence_diff(result),
-            self._format_trigger_diff(result),
-            self._format_procedure_diff(result),
-            self._format_type_diff(result),
-            self._format_extension_diff(result),
-            self._format_fdw_diff(result),
-            self._format_server_diff(result),
-            self._format_event_diff(result),
-            self._format_diff_footer(result),
-        ]
-        return "\n".join(s for s in sections if s)