dbbridgekit 0.1.0__tar.gz

dbbridgekit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Otavio R Santana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dbbridgekit-0.1.0/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: dbbridgekit
+Version: 0.1.0
+Summary: Plataforma genérica de conversão/análise/migração entre bancos de dados via Intermediate Representation (IR) canônica — SQLite, PostgreSQL, MySQL (em progresso), SQL Server (planejado).
+Author-email: Otavio R Santana <tvostrodrigues8@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/tvost2/dbbridge
+Project-URL: Repository, https://github.com/tvost2/dbbridge
+Project-URL: Issues, https://github.com/tvost2/dbbridge/issues
+Project-URL: Documentation, https://github.com/tvost2/dbbridge/blob/main/docs/guide.md
+Project-URL: Changelog, https://github.com/tvost2/dbbridge/blob/main/CHANGELOG.md
+Keywords: sql,sqlite,postgresql,mysql,migration,ir,database
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg[binary]>=3.1
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# DBBridge
+
+Plataforma genérica de conversão, análise e migração entre bancos de dados, baseada numa
+**Intermediate Representation (IR)** canônica — não um conversor pareado por combinação de bancos.
+
+```txt
+Banco origem → Parser do dialeto origem → IR canônica → Renderer do dialeto destino → Banco destino
+```
+
+Evolução do [PostgresModel](../postgresmodel) generalizada: em vez de assumir SQLite→PostgreSQL
+sempre, qualquer par de dialetos suportados passa pelo mesmo pipeline.
+
+## Status (Fase 1)
+
+| Dialeto | Parser | Renderer |
+|---|---|---|
+| SQLite | ✅ | ✅ |
+| PostgreSQL | ✅ | ✅ |
+| MySQL | estrutura registrada (Fase 2) | estrutura registrada (Fase 2) |
+| SQL Server | estrutura registrada (Fase 5) | estrutura registrada (Fase 5) |
+
+`dbbridge.dialects.mysql`/`sqlserver` já registram um dialeto "conhecido, ainda não implementado" —
+`dbbridge dialects` lista os dois, e chamar `.parse()`/`.render_schema()` neles levanta
+`NotImplementedError` com a fase planejada, em vez de um erro genérico de dialeto desconhecido.
+
+167 testes, 99% de cobertura (`pytest --cov=dbbridge`). Os poucos pontos não cobertos são código
+genuinamente inalcançável (stubs de método abstrato, guard `if __name__ == "__main__"`) — ver
+[docs/guide.md](docs/guide.md#cobertura-de-testes).
+
+## Instalação
+
+```bash
+pip install -e .
+# ou, pra rodar contra PostgreSQL de verdade:
+pip install -e ".[dev]"
+```
+
+## Uso rápido
+
+### Traduzir um schema
+
+```bash
+dbbridge translate --from sqlite --to postgres schema.sql
+```
+
+Casos que o parser/renderer não reconhecem com segurança viram `REVIEW_REQUIRED` no stderr — nunca
+uma tradução inventada.
+
+### Escanear um projeto Python
+
+```bash
+dbbridge scan --from sqlite --to postgres ./meu_projeto
+```
+
+Encontra `execute()`/`executemany()` com SQL potencialmente incompatível entre os dois dialetos:
+placeholders (`?` vs `%s`), `sqlite_master`, `PRAGMA`, `INSERT OR IGNORE`/`OR REPLACE`,
+case-sensitivity de `LIKE`, autoincrement, e mais.
+
+### Migrar código-fonte automaticamente
+
+```bash
+dbbridge patch --from sqlite --to postgres ./meu_projeto   # dry-run, mostra o plano
+dbbridge apply --from sqlite --to postgres ./meu_projeto   # aplica com backup automático
+dbbridge rollback ./meu_projeto                            # desfaz, restaura do backup
+```
+
+Reescreve só literais de string simples sem ambiguidade (troca de placeholder). `f-strings`,
+concatenação e casos ambíguos (aspas duplas, `INSERT OR REPLACE`, etc.) nunca são alterados
+automaticamente — viram `REVIEW_REQUIRED`/`SKIPPED_COMPLEX_EXPRESSION` no plano.
+
+### Migrar dados entre bancos de verdade
+
+```bash
+dbbridge migrate-data --from sqlite --to postgres \
+    --source-dsn ./app.db --target-dsn "host=localhost dbname=app" --tables users leads
+dbbridge validate --from sqlite --to postgres \
+    --source-dsn ./app.db --target-dsn "host=localhost dbname=app" --tables users leads
+```
+
+Copia em lotes, nunca faz `DROP`/`TRUNCATE`, sempre acrescenta. `validate` compara contagens e
+checksum (SHA-256) linha a linha quando a tabela é pequena o bastante.
+
+### Compatibility Mode (código antigo continua rodando)
+
+```python
+from dbbridge import connect
+
+db = connect(source_dialect="sqlite", target_dialect="postgres", dsn="host=localhost dbname=app")
+db.execute("SELECT * FROM users WHERE id=?", (1,))  # vira %s por baixo, roda no Postgres de verdade
+```
+
+Permite migrar a aplicação por partes: o código continua escrito na sintaxe de origem enquanto o
+banco de verdade já é o destino.
+
+## Exemplos executáveis
+
+```bash
+python examples/translate_schema.py         # traduz um schema via API Python
+python examples/scan_and_patch_project.py    # scan -> patch -> apply -> rollback num mini-app
+python examples/compat_mode.py                # Compatibility Mode de ponta a ponta
+DBBRIDGE_EXAMPLE_PG_DSN="host=localhost dbname=..." python examples/full_data_migration.py
+```
+
+Todos os quatro rodam de verdade (não são pseudocódigo) — os três primeiros só precisam do SQLite
+da stdlib; o último precisa de um PostgreSQL acessível via a variável de ambiente indicada.
+
+## Arquitetura
+
+```txt
+dbbridge/
+  cli.py                   # scan|report|translate|patch|apply|migrate-data|validate|rollback|doctor|dialects
+  core/
+    ir.py                  # Schema, Table, Column, ForeignKey, UniqueConstraint, CheckConstraint, Index, View, Trigger, Enum
+    types.py                # CanonicalType, Ambiguity
+    parser.py / renderer.py # contratos + registry (register_parser/get_parser/available_parsers, idem renderer)
+    planner.py              # translate(sql, source, target) — o pipeline completo numa função
+  dialects/
+    sqlite.py, postgres.py  # implementados
+    mysql.py, sqlserver.py  # stubs registrados (NotImplementedError com a fase planejada)
+  scanner/scanner.py        # AST — encontra SQL arriscado por par de dialetos
+  codemod/codemod.py         # AST — reescreve só literais simples sem ambiguidade
+  migration/
+    schema_migration.py     # traduz + aplica DDL (aditivo, nunca DROP/TRUNCATE)
+    data_migration.py        # copia dados em lotes
+    validator.py              # contagens + checksum
+    rollback.py                # restaura código a partir de backup
+  compat/runtime.py          # connect() — Compatibility Mode
+  reports/report.py           # normaliza qualquer resultado pra texto/JSON
+```
+
+Por que IR em vez de conversores pareados: com N dialetos, um conversor direto por par cresce O(N²)
+e duplica a mesma lógica de tipos/constraints em cada combinação. Com um modelo canônico no meio,
+cada dialeto novo precisa de só 1 parser + 1 renderer (O(N)) pra já converter de/para todos os
+outros já implementados.
+
+## Segurança
+
+- Toda alteração de código gera backup antes de escrever, e pode ser revertida via `dbbridge rollback`.
+- Migração de schema/dados é sempre aditiva — nunca `DROP`/`TRUNCATE`/`DELETE`.
+- Casos ambíguos (aspas duplas em literal, `INSERT OR REPLACE`, f-strings, expressões dinâmicas)
+  nunca são "adivinhados" — viram `REVIEW_REQUIRED` pra revisão manual.
+- `apply_changes` verifica `ast.parse()` do arquivo resultante antes de considerar sucesso; se o
+  resultado tiver `SyntaxError`, reverte sozinho a partir do backup.
+
+## Fases
+
+1. **IR + SQLite ↔ PostgreSQL** — atual, completo: parser/renderer dos dois dialetos, scanner,
+   codemod, migração de schema/dados, validação por checksum, rollback, CLI, Compatibility Mode.
+2. MySQL (parser + renderer reais).
+3. Codemod genérico validado contra os 3 dialetos.
+4. Data migration validada nos 4 pares centrais (SQLite/Postgres/MySQL cruzados).
+5. SQL Server.
+6. **Fases futuras (levantadas, ainda não priorizadas):** shadow migration (rodar origem e destino
+   em paralelo comparando resultados antes do cutover final), query replay (reproduzir tráfego real
+   de produção contra o destino como teste de carga/compatibilidade), dashboard web, relatórios em
+   HTML/PDF (hoje só texto/JSON via `reports/report.py`), mecanismo de plugin formal pra dialetos
+   externos (hoje a extensão já é possível via `register_parser`/`register_renderer` — falta só
+   empacotar como plugin instalável separadamente, ex. entry points do Python), e suporte a bancos
+   não-relacionais como MongoDB (exigiria uma IR paralela pra documentos/coleções — ver
+   [docs/compatibility-matrix.md](docs/compatibility-matrix.md#roadmap-além-do-sql-relacional)).
+
+Cada fase só avança depois da anterior validada — ver [docs/guide.md](docs/guide.md) para detalhes
+de arquitetura e extensão pra novos dialetos, [docs/cli-reference.md](docs/cli-reference.md) pra
+todos os comandos, [docs/compatibility-matrix.md](docs/compatibility-matrix.md) pro que já
+funciona vs. planejado, [docs/migration-tutorial.md](docs/migration-tutorial.md) pro passo a passo
+completo, e [docs/production-checklist.md](docs/production-checklist.md) antes de rodar contra
+dados reais.

dbbridgekit-0.1.0/README.md

@@ -0,0 +1,167 @@
+# DBBridge
+
+Plataforma genérica de conversão, análise e migração entre bancos de dados, baseada numa
+**Intermediate Representation (IR)** canônica — não um conversor pareado por combinação de bancos.
+
+```txt
+Banco origem → Parser do dialeto origem → IR canônica → Renderer do dialeto destino → Banco destino
+```
+
+Evolução do [PostgresModel](../postgresmodel) generalizada: em vez de assumir SQLite→PostgreSQL
+sempre, qualquer par de dialetos suportados passa pelo mesmo pipeline.
+
+## Status (Fase 1)
+
+| Dialeto | Parser | Renderer |
+|---|---|---|
+| SQLite | ✅ | ✅ |
+| PostgreSQL | ✅ | ✅ |
+| MySQL | estrutura registrada (Fase 2) | estrutura registrada (Fase 2) |
+| SQL Server | estrutura registrada (Fase 5) | estrutura registrada (Fase 5) |
+
+`dbbridge.dialects.mysql`/`sqlserver` já registram um dialeto "conhecido, ainda não implementado" —
+`dbbridge dialects` lista os dois, e chamar `.parse()`/`.render_schema()` neles levanta
+`NotImplementedError` com a fase planejada, em vez de um erro genérico de dialeto desconhecido.
+
+167 testes, 99% de cobertura (`pytest --cov=dbbridge`). Os poucos pontos não cobertos são código
+genuinamente inalcançável (stubs de método abstrato, guard `if __name__ == "__main__"`) — ver
+[docs/guide.md](docs/guide.md#cobertura-de-testes).
+
+## Instalação
+
+```bash
+pip install -e .
+# ou, pra rodar contra PostgreSQL de verdade:
+pip install -e ".[dev]"
+```
+
+## Uso rápido
+
+### Traduzir um schema
+
+```bash
+dbbridge translate --from sqlite --to postgres schema.sql
+```
+
+Casos que o parser/renderer não reconhecem com segurança viram `REVIEW_REQUIRED` no stderr — nunca
+uma tradução inventada.
+
+### Escanear um projeto Python
+
+```bash
+dbbridge scan --from sqlite --to postgres ./meu_projeto
+```
+
+Encontra `execute()`/`executemany()` com SQL potencialmente incompatível entre os dois dialetos:
+placeholders (`?` vs `%s`), `sqlite_master`, `PRAGMA`, `INSERT OR IGNORE`/`OR REPLACE`,
+case-sensitivity de `LIKE`, autoincrement, e mais.
+
+### Migrar código-fonte automaticamente
+
+```bash
+dbbridge patch --from sqlite --to postgres ./meu_projeto   # dry-run, mostra o plano
+dbbridge apply --from sqlite --to postgres ./meu_projeto   # aplica com backup automático
+dbbridge rollback ./meu_projeto                            # desfaz, restaura do backup
+```
+
+Reescreve só literais de string simples sem ambiguidade (troca de placeholder). `f-strings`,
+concatenação e casos ambíguos (aspas duplas, `INSERT OR REPLACE`, etc.) nunca são alterados
+automaticamente — viram `REVIEW_REQUIRED`/`SKIPPED_COMPLEX_EXPRESSION` no plano.
+
+### Migrar dados entre bancos de verdade
+
+```bash
+dbbridge migrate-data --from sqlite --to postgres \
+    --source-dsn ./app.db --target-dsn "host=localhost dbname=app" --tables users leads
+dbbridge validate --from sqlite --to postgres \
+    --source-dsn ./app.db --target-dsn "host=localhost dbname=app" --tables users leads
+```
+
+Copia em lotes, nunca faz `DROP`/`TRUNCATE`, sempre acrescenta. `validate` compara contagens e
+checksum (SHA-256) linha a linha quando a tabela é pequena o bastante.
+
+### Compatibility Mode (código antigo continua rodando)
+
+```python
+from dbbridge import connect
+
+db = connect(source_dialect="sqlite", target_dialect="postgres", dsn="host=localhost dbname=app")
+db.execute("SELECT * FROM users WHERE id=?", (1,))  # vira %s por baixo, roda no Postgres de verdade
+```
+
+Permite migrar a aplicação por partes: o código continua escrito na sintaxe de origem enquanto o
+banco de verdade já é o destino.
+
+## Exemplos executáveis
+
+```bash
+python examples/translate_schema.py         # traduz um schema via API Python
+python examples/scan_and_patch_project.py    # scan -> patch -> apply -> rollback num mini-app
+python examples/compat_mode.py                # Compatibility Mode de ponta a ponta
+DBBRIDGE_EXAMPLE_PG_DSN="host=localhost dbname=..." python examples/full_data_migration.py
+```
+
+Todos os quatro rodam de verdade (não são pseudocódigo) — os três primeiros só precisam do SQLite
+da stdlib; o último precisa de um PostgreSQL acessível via a variável de ambiente indicada.
+
+## Arquitetura
+
+```txt
+dbbridge/
+  cli.py                   # scan|report|translate|patch|apply|migrate-data|validate|rollback|doctor|dialects
+  core/
+    ir.py                  # Schema, Table, Column, ForeignKey, UniqueConstraint, CheckConstraint, Index, View, Trigger, Enum
+    types.py                # CanonicalType, Ambiguity
+    parser.py / renderer.py # contratos + registry (register_parser/get_parser/available_parsers, idem renderer)
+    planner.py              # translate(sql, source, target) — o pipeline completo numa função
+  dialects/
+    sqlite.py, postgres.py  # implementados
+    mysql.py, sqlserver.py  # stubs registrados (NotImplementedError com a fase planejada)
+  scanner/scanner.py        # AST — encontra SQL arriscado por par de dialetos
+  codemod/codemod.py         # AST — reescreve só literais simples sem ambiguidade
+  migration/
+    schema_migration.py     # traduz + aplica DDL (aditivo, nunca DROP/TRUNCATE)
+    data_migration.py        # copia dados em lotes
+    validator.py              # contagens + checksum
+    rollback.py                # restaura código a partir de backup
+  compat/runtime.py          # connect() — Compatibility Mode
+  reports/report.py           # normaliza qualquer resultado pra texto/JSON
+```
+
+Por que IR em vez de conversores pareados: com N dialetos, um conversor direto por par cresce O(N²)
+e duplica a mesma lógica de tipos/constraints em cada combinação. Com um modelo canônico no meio,
+cada dialeto novo precisa de só 1 parser + 1 renderer (O(N)) pra já converter de/para todos os
+outros já implementados.
+
+## Segurança
+
+- Toda alteração de código gera backup antes de escrever, e pode ser revertida via `dbbridge rollback`.
+- Migração de schema/dados é sempre aditiva — nunca `DROP`/`TRUNCATE`/`DELETE`.
+- Casos ambíguos (aspas duplas em literal, `INSERT OR REPLACE`, f-strings, expressões dinâmicas)
+  nunca são "adivinhados" — viram `REVIEW_REQUIRED` pra revisão manual.
+- `apply_changes` verifica `ast.parse()` do arquivo resultante antes de considerar sucesso; se o
+  resultado tiver `SyntaxError`, reverte sozinho a partir do backup.
+
+## Fases
+
+1. **IR + SQLite ↔ PostgreSQL** — atual, completo: parser/renderer dos dois dialetos, scanner,
+   codemod, migração de schema/dados, validação por checksum, rollback, CLI, Compatibility Mode.
+2. MySQL (parser + renderer reais).
+3. Codemod genérico validado contra os 3 dialetos.
+4. Data migration validada nos 4 pares centrais (SQLite/Postgres/MySQL cruzados).
+5. SQL Server.
+6. **Fases futuras (levantadas, ainda não priorizadas):** shadow migration (rodar origem e destino
+   em paralelo comparando resultados antes do cutover final), query replay (reproduzir tráfego real
+   de produção contra o destino como teste de carga/compatibilidade), dashboard web, relatórios em
+   HTML/PDF (hoje só texto/JSON via `reports/report.py`), mecanismo de plugin formal pra dialetos
+   externos (hoje a extensão já é possível via `register_parser`/`register_renderer` — falta só
+   empacotar como plugin instalável separadamente, ex. entry points do Python), e suporte a bancos
+   não-relacionais como MongoDB (exigiria uma IR paralela pra documentos/coleções — ver
+   [docs/compatibility-matrix.md](docs/compatibility-matrix.md#roadmap-além-do-sql-relacional)).
+
+Cada fase só avança depois da anterior validada — ver [docs/guide.md](docs/guide.md) para detalhes
+de arquitetura e extensão pra novos dialetos, [docs/cli-reference.md](docs/cli-reference.md) pra
+todos os comandos, [docs/compatibility-matrix.md](docs/compatibility-matrix.md) pro que já
+funciona vs. planejado, [docs/migration-tutorial.md](docs/migration-tutorial.md) pro passo a passo
+completo, e [docs/production-checklist.md](docs/production-checklist.md) antes de rodar contra
+dados reais.

dbbridgekit-0.1.0/dbbridge/__init__.py

@@ -0,0 +1,22 @@
+"""DBBridge — plataforma genérica de conversão/análise/migração entre bancos de dados, baseada numa
+Intermediate Representation (IR) canônica.
+
+    Banco origem -> Parser do dialeto origem -> IR -> Renderer do dialeto destino -> Banco destino
+
+Não é uma evolução ad-hoc pareada (SQLite->Postgres, SQLite->MySQL, ...) — é uma arquitetura N-para-N
+através de UM modelo comum. Ver core/ir.py pra IR, core/planner.py pro pipeline completo.
+
+    from dbbridge.core.planner import translate
+    result = translate(sql, source_dialect="sqlite", target_dialect="postgres")
+    print(result.sql)
+
+Fase 1 (atual): IR completa + SQLite <-> PostgreSQL, scanner, codemod, CLI, rollback.
+Dialetos MySQL/SQL Server: estrutura registrada, implementação nas Fases 2/5 (ver README.md).
+"""
+from . import dialects  # noqa: F401 — registra sqlite/postgres/mysql(stub)/sqlserver(stub)
+from .compat.runtime import connect
+from .core.planner import TranslationResult, translate
+
+__version__ = "0.1.0"
+
+__all__ = ["translate", "TranslationResult", "connect"]

dbbridgekit-0.1.0/dbbridge/cli.py

@@ -0,0 +1,177 @@
+"""CLI: dbbridge scan|report|translate|patch|apply|migrate-data|validate|rollback|doctor."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import dialects  # noqa: F401 — garante que sqlite/postgres/mysql/sqlserver estão registrados
+from .codemod.codemod import apply_changes, plan_file
+from .core.parser import available_parsers
+from .core.planner import translate as translate_ir
+from .core.renderer import available_renderers
+from .migration.rollback import rollback_code_changes
+from .reports.report import render_report
+from .scanner.scanner import scan_project
+
+
+def _add_common(p: argparse.ArgumentParser):
+    p.add_argument("--from", dest="source", required=True, choices=available_parsers(), help="Dialeto de origem")
+    p.add_argument("--to", dest="target", required=True, choices=available_renderers(), help="Dialeto de destino")
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="dbbridge", description="Conversão/análise/migração entre bancos de dados via IR canônica")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_scan = sub.add_parser("scan", help="Varre um projeto Python procurando SQL incompatível entre os dois dialetos")
+    _add_common(p_scan)
+    p_scan.add_argument("path")
+    p_scan.add_argument("--json", action="store_true")
+
+    p_report = sub.add_parser("report", help="Gera relatório do último scan (texto ou JSON)")
+    p_report.add_argument("path")
+    p_report.add_argument("--from", dest="source", choices=available_parsers())
+    p_report.add_argument("--to", dest="target", choices=available_renderers())
+    p_report.add_argument("--json", action="store_true")
+    p_report.add_argument("--out", default=None)
+
+    p_translate = sub.add_parser("translate", help="Traduz um arquivo .sql (schema DDL) de um dialeto pro outro")
+    _add_common(p_translate)
+    p_translate.add_argument("sql_file")
+    p_translate.add_argument("--out", default=None)
+
+    p_patch = sub.add_parser("patch", help="Gera o plano de mudanças de código SEM escrever nada (dry-run)")
+    _add_common(p_patch)
+    p_patch.add_argument("path")
+
+    p_apply = sub.add_parser("apply", help="Aplica as mudanças de código seguras (com backup automático)")
+    _add_common(p_apply)
+    p_apply.add_argument("path")
+
+    p_migrate = sub.add_parser("migrate-data", help="Copia dados entre uma conexão origem e uma destino")
+    _add_common(p_migrate)
+    p_migrate.add_argument("--source-dsn", required=True)
+    p_migrate.add_argument("--target-dsn", required=True)
+    p_migrate.add_argument("--tables", nargs="+", required=True)
+
+    p_validate = sub.add_parser("validate", help="Valida contagens/checksums entre origem e destino após migrate-data")
+    _add_common(p_validate)
+    p_validate.add_argument("--source-dsn", required=True)
+    p_validate.add_argument("--target-dsn", required=True)
+    p_validate.add_argument("--tables", nargs="+", required=True)
+
+    p_rollback = sub.add_parser("rollback", help="Restaura arquivos de código a partir do backup mais recente")
+    p_rollback.add_argument("path")
+
+    sub.add_parser("doctor", help="Diagnóstico rápido: dialetos disponíveis, drivers instalados")
+    sub.add_parser("dialects", help="Lista os dialetos com parser/renderer disponíveis")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "scan":
+        report = scan_project(Path(args.path), args.source, args.target)
+        print(render_report(f"DBBridge scan ({args.source} -> {args.target})", report, fmt="json" if args.json else "text"))
+
+    elif args.command == "report":
+        report = scan_project(Path(args.path), args.source or "sqlite", args.target or "postgres")
+        text = render_report(f"DBBridge report ({args.source} -> {args.target})", report, fmt="json" if args.json else "text")
+        if args.out:
+            Path(args.out).write_text(text, encoding="utf-8")
+            print(f"Relatório salvo em {args.out}")
+        else:
+            print(text)
+
+    elif args.command == "translate":
+        sql = Path(args.sql_file).read_text(encoding="utf-8")
+        result = translate_ir(sql, args.source, args.target)
+        if args.out:
+            Path(args.out).write_text(result.sql, encoding="utf-8")
+            print(f"SQL traduzido salvo em {args.out}")
+        else:
+            print(result.sql)
+        if result.review_required:
+            print("\n--- REVIEW_REQUIRED ---", file=sys.stderr)
+            for f in result.parse_findings:
+                print(f"  [parse] {f.statement[:80]!r}: {f.reason}", file=sys.stderr)
+            # Nenhum parser atual produz Trigger/View no IR que gere RenderFinding (CREATE TRIGGER já
+            # vira ParseFinding antes de chegar aqui) — mantido para dialetos futuros que possam parsear
+            # esses casos com sucesso e só falhar na hora de renderizar pro destino.
+            for f in result.render_findings:
+                print(f"  [render] {f.target}: {f.reason}", file=sys.stderr)
+
+    elif args.command == "patch":
+        total = 0
+        for path in sorted(Path(args.path).rglob("*.py")):
+            if any(part in ("venv", ".venv", "__pycache__") for part in path.parts):
+                continue
+            changes = plan_file(path, args.source, args.target)
+            if changes:
+                print(f"\n{path}:")
+                for c in changes:
+                    print(f"  [{c.status}] linha {c.line}: {c.reason}")
+                total += len(changes)
+        print(f"\nTotal planejado: {total} mudança(s). Nada foi escrito — rode 'apply' pra gravar.")
+
+    elif args.command == "apply":
+        applied_total = 0
+        touched = []
+        backup_dir = Path(args.path) / ".dbbridge_backups"
+        for path in sorted(Path(args.path).rglob("*.py")):
+            if any(part in ("venv", ".venv", "__pycache__", ".dbbridge_backups") for part in path.parts):
+                continue
+            changes = plan_file(path, args.source, args.target)
+            if not changes:
+                continue
+            ok = apply_changes(path, changes, backup_dir)
+            if ok:
+                n = sum(1 for c in changes if c.status == "APPLIED")
+                if n:
+                    applied_total += n
+                    touched.append(path)
+        print(f"{applied_total} mudança(s) aplicada(s) em {len(touched)} arquivo(s).")
+
+    elif args.command == "migrate-data":
+        from .compat.runtime import connect as db_connect
+        from .migration.data_migration import migrate_data
+
+        source_conn = db_connect(args.source, args.source, args.source_dsn)
+        target_conn = db_connect(args.source, args.target, args.target_dsn)
+        result = migrate_data(source_conn, target_conn, args.tables)
+        print(render_report(f"DBBridge migrate-data ({args.source} -> {args.target})", result))
+        if not result.all_counts_match:
+            sys.exit(1)
+
+    elif args.command == "validate":
+        from .compat.runtime import connect as db_connect
+        from .migration.validator import validate
+
+        source_conn = db_connect(args.source, args.source, args.source_dsn)
+        target_conn = db_connect(args.source, args.target, args.target_dsn)
+        report = validate(source_conn, target_conn, {t: None for t in args.tables})
+        print(render_report(f"DBBridge validate ({args.source} -> {args.target})", report))
+        if not report.all_ok:
+            sys.exit(1)
+
+    elif args.command == "rollback":
+        n = rollback_code_changes(Path(args.path))
+        print(f"{n} arquivo(s) restaurado(s) a partir do backup.")
+
+    elif args.command == "doctor":
+        print("Dialetos com parser:", available_parsers())
+        print("Dialetos com renderer:", available_renderers())
+        try:
+            import psycopg  # noqa: F401
+            print("psycopg (Postgres driver): instalado")
+        except ImportError:
+            print("psycopg (Postgres driver): NÃO instalado")
+        import sqlite3  # noqa: F401
+        print("sqlite3 (stdlib): disponível")
+
+    elif args.command == "dialects":
+        print("Parsers disponíveis:", available_parsers())
+        print("Renderers disponíveis:", available_renderers())
+
+
+if __name__ == "__main__":
+    main()

dbbridgekit-0.1.0/dbbridge/codemod/__init__.py

@@ -0,0 +1,3 @@
+from .codemod import APPLIED, REVIEW_REQUIRED, SKIPPED_COMPLEX, CodemodChange, apply_changes, plan_file
+
+__all__ = ["APPLIED", "REVIEW_REQUIRED", "SKIPPED_COMPLEX", "CodemodChange", "apply_changes", "plan_file"]