plain.postgres 0.89.1__tar.gz → 0.90.0__tar.gz

plain_postgres-0.89.1/plain/postgres/README.md → plain_postgres-0.90.0/PKG-INFO

@@ -1,3 +1,15 @@
+Metadata-Version: 2.4
+Name: plain.postgres
+Version: 0.90.0
+Summary: Model your data and store it in a database.
+Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: plain<1.0.0,>=0.129.0
+Requires-Dist: sqlparse>=0.3.1
+Description-Content-Type: text/markdown
+
 # plain.postgres
 
 **Model your data and store it in a database.**
@@ -142,8 +154,8 @@ class PublishedQuerySet(postgres.QuerySet["Article"]):
 
 @postgres.register_model
 class Article(postgres.Model):
-    title: str = types.CharField(max_length=200)
-    status: str = types.CharField(max_length=20)
+    title: str = types.TextField(max_length=200)
+    status: str = types.TextField(max_length=20)
 
     query = PublishedQuerySet()
 
@@ -496,7 +508,31 @@ Use this when migrations have already been committed or deployed to other enviro
 | ----------------------------------------- | ------------------------------------------------------- |
 | Migrations are local only (not committed) | Delete-and-recreate                                     |
 | Migrations are committed but not deployed | Delete-and-recreate (if all developers reset) or squash |
-| Migrations are deployed to production     | Squash                                                  |
+| Migrations are deployed to production     | Squash or full reset                                    |
+
+### Resetting migrations
+
+Over time a package can accumulate dozens of migrations. Once **every environment** (dev, staging, production) has applied all of them, you can replace the entire history with a single fresh `0001_initial`.
+
+**Prerequisites:**
+
+- Every environment (dev, staging, production) has applied all existing migrations. If any environment is behind, the reset will break it.
+- The first migration is named `0001_initial` (the default). If it has a different name, this workflow won't work cleanly.
+
+**Steps:**
+
+1. Run `plain migrations list` locally and verify everything is applied.
+2. Delete every file in the package's `migrations/` directory except `__init__.py`.
+3. Run `plain makemigrations` to generate a fresh `0001_initial`.
+4. Run `plain migrations prune --yes` to remove stale DB records. The existing `0001_initial` record matches the new file, so the database is immediately up to date.
+5. Verify with `plain postgres schema` (zero issues means the reset is clean) and `plain makemigrations --check` (no pending changes).
+6. Commit and deploy. On every other environment, run `plain migrations prune --yes`. No actual SQL runs — it only cleans up migration history records. If `migrations prune` is already in your deploy steps, no changes are needed.
+
+**Things to keep in mind:**
+
+- If resetting multiple packages, process depended-on packages first — the new `0001_initial` may have cross-package FK dependencies.
+- Data migrations (`RunPython`) in the deleted history are gone, which is fine since they've already run everywhere.
+- If CI runs `makemigrations --check` or `migrate --check`, the reset PR must be merged and deployed before those checks pass in other branches.
 
 ### Other migration commands
 
@@ -516,7 +552,7 @@ from plain.postgres import types
 
 class Product(postgres.Model):
     # Text fields
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     description: str = types.TextField()
 
     # Numeric fields
@@ -533,8 +569,7 @@ class Product(postgres.Model):
 
 **Text fields:**
 
-- [`CharField`](./fields/__init__.py#CharField) - String with max length
-- [`TextField`](./fields/__init__.py#TextField) - Unlimited text
+- [`TextField`](./fields/__init__.py#TextField) - Text (with optional max length)
 - [`EmailField`](./fields/__init__.py#EmailField) - Email address (validated)
 - [`URLField`](./fields/__init__.py#URLField) - URL (validated)
 
@@ -623,7 +658,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Integration(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     api_key: str = types.EncryptedTextField(max_length=200)
     credentials: dict = types.EncryptedJSONField(required=False, allow_null=True)
 ```
@@ -658,7 +693,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField("Author", on_delete=postgres.CASCADE)
     tags = types.ManyToManyField("Tag")
 ```
@@ -673,13 +708,13 @@ from plain.postgres import types
 
 @postgres.register_model
 class Author(postgres.Model):
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     # Explicit reverse accessor for all books by this author
     books = types.ReverseForeignKey(to="Book", field="author")
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField(Author, on_delete=postgres.CASCADE)
 
 # Usage
@@ -696,13 +731,13 @@ For many-to-many relationships:
 ```python
 @postgres.register_model
 class Feature(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     # Explicit reverse accessor for all cars with this feature
     cars = types.ReverseManyToMany(to="Car", field="features")
 
 @postgres.register_model
 class Car(postgres.Model):
-    model: str = types.CharField(max_length=100)
+    model: str = types.TextField(max_length=100)
     features = types.ManyToManyField(Feature)
 
 # Usage
@@ -769,7 +804,7 @@ You can optimize queries and ensure data integrity with indexes and constraints:
 ```python
 class User(postgres.Model):
     email: str = types.EmailField()
-    username: str = types.CharField(max_length=150)
+    username: str = types.TextField(max_length=150)
     age: int = types.IntegerField()
 
     model_options = postgres.Options(
@@ -793,12 +828,12 @@ Add indexes for columns that appear in `.filter()`, `.order_by()`, or `.exclude(
 ```python
 # Bad — full table scan on every filtered query
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
 # Good — indexed for common queries
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
     model_options = postgres.Options(
@@ -840,10 +875,10 @@ Use `default=""` instead of `allow_null=True` to avoid two representations of "e
 
 ```python
 # Bad — NULL and "" both mean "empty"
-nickname: str = types.CharField(max_length=50, allow_null=True)
+nickname: str = types.TextField(max_length=50, allow_null=True)
 
 # Good — single empty representation
-nickname: str = types.CharField(max_length=50, default="")
+nickname: str = types.TextField(max_length=50, default="")
 ```
 
 ## Forms
@@ -1005,10 +1040,6 @@ See [`default_settings.py`](./default_settings.py) for more details.
 
 Add the field to your model class, then run `plain makemigrations` to create a migration. If the field is required (no default value and not nullable), you'll be prompted to provide a default value for existing rows.
 
-#### What's the difference between `CharField` and `TextField`?
-
-`CharField` requires a `max_length` and is typically used for short strings like names or emails. `TextField` has no length limit and is used for longer content like descriptions or body text.
-
 #### How do I create a unique constraint on multiple fields?
 
 Use `UniqueConstraint` in your model's `model_options`:

{plain_postgres-0.89.1 → plain_postgres-0.90.0}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,38 @@
 # plain-postgres changelog
 
+## [0.90.0](https://github.com/dropseed/plain/releases/plain-postgres@0.90.0) (2026-03-28)
+
+### What's changed
+
+- **Removed `CharField`** — use `TextField` for all string fields. PostgreSQL treats `varchar` and `text` identically (same storage, same performance), so the distinction was unnecessary. `TextField` now accepts an optional `max_length` for Python-side validation via `MaxLengthValidator`, without affecting the database column type. ([5062ee4dd1fd](https://github.com/dropseed/plain/commit/5062ee4dd1fd))
+- **`EmailField` and `URLField` now extend `TextField`** instead of `CharField`. Their default `max_length` values (254 and 200 respectively) have been removed — pass `max_length` explicitly if you need validation. ([5062ee4dd1fd](https://github.com/dropseed/plain/commit/5062ee4dd1fd))
+- **Simplified field class internals** — removed the `get_internal_type()` method and 6 lookup dicts from `dialect.py`. Each field class now declares its SQL type directly via `db_type_sql` class attribute. String-based type comparisons replaced with `isinstance()` checks throughout. ([3ffdebe22250](https://github.com/dropseed/plain/commit/3ffdebe22250))
+- **Added `postgres converge` command** — detects and fixes safe schema mismatches between models and the database. Currently handles `character varying` → `text` conversions. ([fe8cf3995e95](https://github.com/dropseed/plain/commit/fe8cf3995e95))
+
+### Upgrade instructions
+
+- Replace `CharField` with `TextField` in model code (e.g. `types.CharField(max_length=100)` → `types.TextField(max_length=100)`)
+- Replace `CharField` with `TextField` in migration files (e.g. `postgres.CharField(max_length=255)` → `postgres.TextField(max_length=255)`)
+- If you subclass `CharField`, change the parent class to `TextField`
+- `EmailField` no longer defaults `max_length=254` and `URLField` no longer defaults `max_length=200` — remove these from migration files if present (e.g. `postgres.EmailField(max_length=254)` → `postgres.EmailField()`)
+- Run `plain postgres converge` to convert existing `character varying` columns to `text` (in development and production). The conversion is instant and safe — PostgreSQL treats them identically. Use `--yes` to skip confirmation in CI/deploy scripts.
+
+## [0.89.2](https://github.com/dropseed/plain/releases/plain-postgres@0.89.2) (2026-03-27)
+
+### What's changed
+
+- Fixed `schema` command miscategorizing expression-based unique constraints as missing columns ([93ab244416f8](https://github.com/dropseed/plain/commit/93ab244416f8))
+- Used canonical Postgres type names in `DATA_TYPES` mapping, removing the `_normalize_type` helper ([f581fe6009bd](https://github.com/dropseed/plain/commit/f581fe6009bd))
+- Moved `diagnose/` module to `introspection/`, consolidated into 2 files, added schema introspection functions used by `schema` and `drop-unknown-tables` commands ([86f7f5b85a87](https://github.com/dropseed/plain/commit/86f7f5b85a87))
+- `diagnose --json` now exits 0 — the JSON data is the signal, not the exit code ([86f7f5b85a87](https://github.com/dropseed/plain/commit/86f7f5b85a87))
+- Added migration reset documentation for replacing migration history with a fresh `0001_initial` ([2fa6203379e9](https://github.com/dropseed/plain/commit/2fa6203379e9))
+- Updated form field references from `CharField` to `TextField` in model forms ([4e29f5d6cade](https://github.com/dropseed/plain/commit/4e29f5d6cade))
+- Changed CLI confirmation flags to `--yes`/`-y` across all commands ([0af36e101f03](https://github.com/dropseed/plain/commit/0af36e101f03))
+
+### Upgrade instructions
+
+- Requires `plain>=0.129.0`. If you use `plain postgres diagnose --json` exit codes in CI, note that it now always exits 0 — check the JSON output for issues instead.
+
 ## [0.89.1](https://github.com/dropseed/plain/releases/plain-postgres@0.89.1) (2026-03-26)
 
 ### What's changed

plain_postgres-0.89.1/PKG-INFO → plain_postgres-0.90.0/plain/postgres/README.md

@@ -1,15 +1,3 @@
-Metadata-Version: 2.4
-Name: plain.postgres
-Version: 0.89.1
-Summary: Model your data and store it in a database.
-Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
-License-Expression: BSD-3-Clause
-License-File: LICENSE
-Requires-Python: >=3.13
-Requires-Dist: plain<1.0.0,>=0.126.0
-Requires-Dist: sqlparse>=0.3.1
-Description-Content-Type: text/markdown
-
 # plain.postgres
 
 **Model your data and store it in a database.**
@@ -154,8 +142,8 @@ class PublishedQuerySet(postgres.QuerySet["Article"]):
 
 @postgres.register_model
 class Article(postgres.Model):
-    title: str = types.CharField(max_length=200)
-    status: str = types.CharField(max_length=20)
+    title: str = types.TextField(max_length=200)
+    status: str = types.TextField(max_length=20)
 
     query = PublishedQuerySet()
 
@@ -508,7 +496,31 @@ Use this when migrations have already been committed or deployed to other enviro
 | ----------------------------------------- | ------------------------------------------------------- |
 | Migrations are local only (not committed) | Delete-and-recreate                                     |
 | Migrations are committed but not deployed | Delete-and-recreate (if all developers reset) or squash |
-| Migrations are deployed to production     | Squash                                                  |
+| Migrations are deployed to production     | Squash or full reset                                    |
+
+### Resetting migrations
+
+Over time a package can accumulate dozens of migrations. Once **every environment** (dev, staging, production) has applied all of them, you can replace the entire history with a single fresh `0001_initial`.
+
+**Prerequisites:**
+
+- Every environment (dev, staging, production) has applied all existing migrations. If any environment is behind, the reset will break it.
+- The first migration is named `0001_initial` (the default). If it has a different name, this workflow won't work cleanly.
+
+**Steps:**
+
+1. Run `plain migrations list` locally and verify everything is applied.
+2. Delete every file in the package's `migrations/` directory except `__init__.py`.
+3. Run `plain makemigrations` to generate a fresh `0001_initial`.
+4. Run `plain migrations prune --yes` to remove stale DB records. The existing `0001_initial` record matches the new file, so the database is immediately up to date.
+5. Verify with `plain postgres schema` (zero issues means the reset is clean) and `plain makemigrations --check` (no pending changes).
+6. Commit and deploy. On every other environment, run `plain migrations prune --yes`. No actual SQL runs — it only cleans up migration history records. If `migrations prune` is already in your deploy steps, no changes are needed.
+
+**Things to keep in mind:**
+
+- If resetting multiple packages, process depended-on packages first — the new `0001_initial` may have cross-package FK dependencies.
+- Data migrations (`RunPython`) in the deleted history are gone, which is fine since they've already run everywhere.
+- If CI runs `makemigrations --check` or `migrate --check`, the reset PR must be merged and deployed before those checks pass in other branches.
 
 ### Other migration commands
 
@@ -528,7 +540,7 @@ from plain.postgres import types
 
 class Product(postgres.Model):
     # Text fields
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     description: str = types.TextField()
 
     # Numeric fields
@@ -545,8 +557,7 @@ class Product(postgres.Model):
 
 **Text fields:**
 
-- [`CharField`](./fields/__init__.py#CharField) - String with max length
-- [`TextField`](./fields/__init__.py#TextField) - Unlimited text
+- [`TextField`](./fields/__init__.py#TextField) - Text (with optional max length)
 - [`EmailField`](./fields/__init__.py#EmailField) - Email address (validated)
 - [`URLField`](./fields/__init__.py#URLField) - URL (validated)
 
@@ -635,7 +646,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Integration(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     api_key: str = types.EncryptedTextField(max_length=200)
     credentials: dict = types.EncryptedJSONField(required=False, allow_null=True)
 ```
@@ -670,7 +681,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField("Author", on_delete=postgres.CASCADE)
     tags = types.ManyToManyField("Tag")
 ```
@@ -685,13 +696,13 @@ from plain.postgres import types
 
 @postgres.register_model
 class Author(postgres.Model):
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     # Explicit reverse accessor for all books by this author
     books = types.ReverseForeignKey(to="Book", field="author")
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField(Author, on_delete=postgres.CASCADE)
 
 # Usage
@@ -708,13 +719,13 @@ For many-to-many relationships:
 ```python
 @postgres.register_model
 class Feature(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     # Explicit reverse accessor for all cars with this feature
     cars = types.ReverseManyToMany(to="Car", field="features")
 
 @postgres.register_model
 class Car(postgres.Model):
-    model: str = types.CharField(max_length=100)
+    model: str = types.TextField(max_length=100)
     features = types.ManyToManyField(Feature)
 
 # Usage
@@ -781,7 +792,7 @@ You can optimize queries and ensure data integrity with indexes and constraints:
 ```python
 class User(postgres.Model):
     email: str = types.EmailField()
-    username: str = types.CharField(max_length=150)
+    username: str = types.TextField(max_length=150)
     age: int = types.IntegerField()
 
     model_options = postgres.Options(
@@ -805,12 +816,12 @@ Add indexes for columns that appear in `.filter()`, `.order_by()`, or `.exclude(
 ```python
 # Bad — full table scan on every filtered query
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
 # Good — indexed for common queries
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
     model_options = postgres.Options(
@@ -852,10 +863,10 @@ Use `default=""` instead of `allow_null=True` to avoid two representations of "e
 
 ```python
 # Bad — NULL and "" both mean "empty"
-nickname: str = types.CharField(max_length=50, allow_null=True)
+nickname: str = types.TextField(max_length=50, allow_null=True)
 
 # Good — single empty representation
-nickname: str = types.CharField(max_length=50, default="")
+nickname: str = types.TextField(max_length=50, default="")
 ```
 
 ## Forms
@@ -1017,10 +1028,6 @@ See [`default_settings.py`](./default_settings.py) for more details.
 
 Add the field to your model class, then run `plain makemigrations` to create a migration. If the field is required (no default value and not nullable), you'll be prompted to provide a default value for existing rows.
 
-#### What's the difference between `CharField` and `TextField`?
-
-`CharField` requires a `max_length` and is typically used for short strings like names or emails. `TextField` has no length limit and is used for longer content like descriptions or body text.
-
 #### How do I create a unique constraint on multiple fields?
 
 Use `UniqueConstraint` in your model's `model_options`:

{plain_postgres-0.89.1 → plain_postgres-0.90.0}/plain/postgres/__init__.py

@@ -13,7 +13,6 @@ from .fields import (
     BigIntegerField,
     BinaryField,
     BooleanField,
-    CharField,
     DateField,
     DateTimeField,
     DecimalField,
@@ -63,7 +62,6 @@ __all__ = [
     "BigIntegerField",
     "BinaryField",
     "BooleanField",
-    "CharField",
     "DateField",
     "DateTimeField",
     "DecimalField",

{plain_postgres-0.89.1 → plain_postgres-0.90.0}/plain/postgres/agents/.claude/rules/plain-postgres.md

@@ -12,7 +12,7 @@ Import fields via `from plain.postgres import types` and annotate with Python ty
 ```python
 from plain.postgres import types
 
-name: str = types.CharField(max_length=100)
+name: str = types.TextField(max_length=100)
 car: Car = types.ForeignKeyField("Car", on_delete=postgres.CASCADE)
 ```
 
@@ -69,9 +69,9 @@ Run `uv run plain docs postgres --section querying` for full patterns with code
 
 Run `uv run plain docs postgres --section constraints` for full patterns with code examples.
 
-## Diagnostics
+## Database Doctor
 
-Use the `/plain-postgres-diagnose` skill to run database health checks (unused indexes, missing FK indexes, sequence exhaustion, etc.).
+Use the `/plain-postgres-doctor` skill to check overall database health — migration sync, schema correctness, and operational health.
 
 Run `uv run plain docs postgres --section diagnostics` for check details, thresholds, and production usage.
 

plain_postgres-0.90.0/plain/postgres/agents/.claude/skills/plain-postgres-doctor/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: plain-postgres-doctor
+description: Check overall database health — schema correctness and operational health. Use when asked to check the database, validate schema, optimize indexes, or diagnose Postgres problems.
+---
+
+# Database Doctor
+
+Check database health by running schema and operational checks, then fix any issues found.
+
+**All checks are read-only.** Fixes are local code changes. Never run database mutations (`migrate`, direct SQL) without explicit user approval.
+
+## 1. Dev only or production too?
+
+Always start by checking the dev database — that's where you are and where fixes get verified. Ask the user if they also want to check production. Production is where schema drift and operational health issues matter most, but dev databases drift too (manual SQL, reverted migrations, branch switches).
+
+If checking production, figure out how the user runs commands there (check for Procfiles, Dockerfiles, deploy scripts, etc.) or ask them. Both `schema` and `diagnose` need to run against the target database.
+
+## 2. Run checks
+
+### Schema correctness
+
+```
+uv run plain postgres schema --json
+```
+
+Checks whether the actual database matches what the models expect — drift from failed deploys, manual DDL, partial migrations, or branch switches. Also reports unknown tables (tables in the DB with no corresponding model) which are often left over from uninstalled packages.
+
+### Operational health
+
+```
+uv run plain postgres diagnose --json
+```
+
+Finds unused/duplicate/missing indexes, sequence exhaustion, cache hit ratios, vacuum health, and slow queries. Stats-based checks (unused indexes, cache hit ratios) are most meaningful against production with real traffic. Structural checks (duplicate indexes, missing FK indexes) are valid in any environment.
+
+The JSON output includes `suggestion` fields for each finding. If findings are on unmanaged tables, check whether those tables should exist at all — `schema` will have already flagged them as unknown.
+
+## 3. Fix issues
+
+Make code and migration changes in the local codebase. For app-owned items, this is typically model changes + `uv run plain makemigrations`. For unknown tables, present `uv run plain postgres drop-unknown-tables` to the user — it shows what will be dropped and asks for confirmation. Use `--yes` to skip the prompt if the user wants the agent to run it directly. For other unmanaged items, the suggestions include exact DDL — present these to the user for review, do not run SQL directly.
+
+## 4. Verify
+
+For **structural diagnose findings** (duplicate indexes, missing FK indexes): confirm the issue also appears in dev before fixing — you can't verify a fix if you never saw the problem. Run checks before and after the fix, then deploy and re-verify in production.
+
+For **schema drift**: the drift is environment-specific (prod may have manual DDL that dev doesn't). Verify by confirming your fix makes `schema` pass cleanly in dev, then deploy and re-verify in production.
+
+Stats-based findings (unused indexes, cache hit ratios) can only be verified in production after deploy.

{plain_postgres-0.89.1 → plain_postgres-0.90.0}/plain/postgres/backups/cli.py

@@ -138,11 +138,13 @@ def delete_backup(backup_name: str) -> None:
 
 
 @cli.command("clear")
-@click.confirmation_option(prompt="Are you sure you want to delete all backups?")
-def clear_backups() -> None:
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt.")
+def clear_backups(yes: bool) -> None:
     """Clear all database backups"""
     backups_handler = DatabaseBackups()
     backups = backups_handler.find_backups()
+    if not yes:
+        click.confirm("Are you sure you want to delete all backups?", abort=True)
     for backup in backups:
         backup.delete()
     click.secho("All backups deleted", fg="green")

plain_postgres-0.90.0/plain/postgres/cli/converge.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import click
+
+from ..db import get_connection
+from ..dialect import quote_name
+from ..introspection import check_model
+from ..registry import models_registry
+
+
+@click.command()
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    help="Skip confirmation prompt.",
+)
+def converge(yes: bool) -> None:
+    """Fix safe schema mismatches between models and the database.
+
+    Detects column type mismatches that can be fixed without data loss
+    (e.g. character varying → text) and applies ALTER COLUMN TYPE statements.
+    """
+    conn = get_connection()
+    fixes: list[tuple[str, str, str, str]] = []  # (table, column, actual, expected)
+
+    with conn.cursor() as cursor:
+        for model in models_registry.get_models():
+            result = check_model(conn, cursor, model)
+            table = result["table"]
+            for col in result["columns"]:
+                for issue in col["issues"]:
+                    if issue["kind"] == "type_mismatch":
+                        expected = issue["detail"].split("expected ")[1].split(",")[0]
+                        actual = issue["detail"].split("actual ")[1]
+                        if _is_safe_type_fix(actual, expected):
+                            fixes.append((table, col["name"], actual, expected))
+
+    if not fixes:
+        click.secho("Schema is converged — nothing to fix.", fg="green")
+        return
+
+    click.secho(
+        f"{len(fixes)} column{'s' if len(fixes) != 1 else ''} to fix:\n", bold=True
+    )
+    for table, column, actual, expected in fixes:
+        click.echo(f"  {table}.{column}: ", nl=False)
+        click.secho(actual, fg="red", nl=False)
+        click.echo(" → ", nl=False)
+        click.secho(expected, fg="green")
+
+    click.echo()
+
+    if not yes:
+        if not click.confirm("Apply these changes?"):
+            return
+
+    click.echo()
+
+    with conn.cursor() as cursor:
+        for table, column, actual, expected in fixes:
+            sql = f"ALTER TABLE {quote_name(table)} ALTER COLUMN {quote_name(column)} TYPE {expected}"
+            click.echo(f"  {sql}")
+            cursor.execute(sql)
+
+    conn.commit()
+
+    click.echo()
+    click.secho(
+        f"Fixed {len(fixes)} column{'s' if len(fixes) != 1 else ''}.", fg="green"
+    )
+
+
+def _is_safe_type_fix(actual: str, expected: str) -> bool:
+    """Return True if converting actual → expected is safe (no data loss, no rewrite)."""
+    # character varying(N) → text is always safe in PostgreSQL.
+    # They use the same storage format; the ALTER is metadata-only.
+    if actual.startswith("character varying") and expected == "text":
+        return True
+    return False

{plain_postgres-0.89.1 → plain_postgres-0.90.0}/plain/postgres/cli/core.py

@@ -13,7 +13,7 @@ from plain.cli import register_cli
 from ..backups.cli import cli as backups_cli
 from ..db import get_connection
 from ..dialect import quote_name
-from ..migrations.recorder import MIGRATION_TABLE_NAME
+from .converge import converge
 from .diagnose import diagnose
 from .schema import schema
 
@@ -25,6 +25,7 @@ def cli() -> None:
 
 
 cli.add_command(backups_cli)
+cli.add_command(converge)
 cli.add_command(diagnose)
 cli.add_command(schema)
 
@@ -62,15 +63,16 @@ def shell(parameters: tuple[str, ...]) -> None:
 @cli.command("drop-unknown-tables")
 @click.option(
     "--yes",
+    "-y",
     is_flag=True,
-    help="Skip confirmation prompt (for non-interactive use).",
+    help="Skip confirmation prompt.",
 )
 def drop_unknown_tables(yes: bool) -> None:
     """Drop all tables not associated with a Plain model"""
+    from ..introspection import get_unknown_tables
+
     conn = get_connection()
-    db_tables = set(conn.table_names())
-    model_tables = set(conn.plain_table_names())
-    unknown_tables = sorted(db_tables - model_tables - {MIGRATION_TABLE_NAME})
+    unknown_tables = get_unknown_tables(conn)
 
     if not unknown_tables:
         click.echo("No unknown tables found.")

{plain_postgres-0.89.1 → plain_postgres-0.90.0}/plain/postgres/cli/diagnose.py

@@ -7,7 +7,7 @@ from typing import Any
 import click
 
 from ..db import get_connection
-from ..diagnose import CheckItem, CheckResult, build_table_owners, run_all_checks
+from ..introspection import CheckItem, CheckResult, build_table_owners, run_all_checks
 
 STATUS_SYMBOLS = {
     "ok": ("✓", "green"),
@@ -199,6 +199,6 @@ def diagnose(output_json: bool, show_all: bool) -> None:
     else:
         format_human(results, context, show_all=show_all)
 
-    # Exit 1 if any critical
-    if any(r["status"] == "critical" for r in results):
+    # Exit 1 if any critical (JSON mode always exits 0 — the data is the signal)
+    if not output_json and any(r["status"] == "critical" for r in results):
         sys.exit(1)

{plain_postgres-0.89.1 → plain_postgres-0.90.0}/plain/postgres/cli/migrations.py

@@ -777,8 +777,9 @@ def list_migrations(
 @cli.command("prune")
 @click.option(
     "--yes",
+    "-y",
     is_flag=True,
-    help="Skip confirmation prompt (for non-interactive use).",
+    help="Skip confirmation prompt.",
 )
 def prune(yes: bool) -> None:
     """Remove stale migration records from the database"""