tina4-python 3.13.120__tar.gz → 3.13.121__tar.gz

{tina4_python-3.13.120 → tina4_python-3.13.121}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tina4-python
-Version: 3.13.120
+Version: 3.13.121
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.120 → tina4_python-3.13.121}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.120"
+version = "3.13.121"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.120 → tina4_python-3.13.121}/tina4_python/__init__.py

@@ -51,7 +51,7 @@ def _resolve_version() -> str:
     #
     # test_version_constant.py now asserts this literal equals the pyproject
     # version, so the release bump cannot leave it behind again.
-    return "3.13.120"
+    return "3.13.121"
 
 
 __version__ = _resolve_version()

{tina4_python-3.13.120 → tina4_python-3.13.121}/tina4_python/cli/__init__.py

@@ -732,14 +732,35 @@ def _migrate(args):
 
 
 def _migrate_create(args):
-    """Create a new migration file."""
+    """Create a new migration file.
+
+    Thin delegation to `_emit_resolution("migration", ...)` — the same code
+    path `tina4python generate migration <desc>` takes — so both CLI surfaces
+    emit the SAME ADR-0063 `generate_v1_1` envelope, the SAME `tina4:edit`
+    markers in the file, and the SAME next-steps block. The only intentional
+    difference is that `migrate:create` never co-emits a test file (a private
+    `_no_test` marker on the flags dict suppresses the test-emit path in
+    `_gen_migration` and drops `test_paths[]` in the resolution), preserving
+    the "just a migration, no test" contract of `migrate:create`. Neither
+    surface is deprecated; both stay first-class producers of the envelope.
+
+    The Python API `create_migration()` in `tina4_python.migration.runner` is
+    unchanged and still callable directly.
+    """
     if not args:
         print("Usage: tina4python migrate:create <description>")
         sys.exit(1)
-    from tina4_python.migration import create_migration
-    desc = " ".join(args)
-    path = create_migration(desc, "migrations")
-    print(f"Created: {path}")
+    # Split flags vs positional so `--json` / `--dry-run` flow through the
+    # envelope emitter (bare word args form the description).
+    flags, positional = _parse_flags(list(args))
+    if not positional:
+        print("Usage: tina4python migrate:create <description>")
+        sys.exit(1)
+    desc = " ".join(positional)
+    # Private marker read by _gen_migration + _resolve_generation to suppress
+    # the co-emitted test — see the `migrate:create` contract above.
+    flags["_no_test"] = True
+    _emit_resolution("migration", desc, flags)
 
 
 def _migrate_rollback(args):
@@ -1189,6 +1210,10 @@ def _resolve_generation(target: str, name: str, flags: dict,
         table = _to_snake(table)
         filename = f"{ts}_{name}.sql"
         is_create = name.startswith("create_")
+        # Private `_no_test` marker (set by `migrate:create`, which is a
+        # single-file operation): drop `test_paths[]` so the envelope
+        # matches the on-disk effect. `_gen_migration` reads the same flag.
+        want_test = is_create and not flags.get("_no_test")
         return {
             "class_name": None,
             "table_name": table,
@@ -1196,7 +1221,7 @@ def _resolve_generation(target: str, name: str, flags: dict,
             "migration_path": f"migrations/{filename}",
             "transformations": [],
             "routes": [],
-            "test_paths": [f"tests/test_{table}_migration.py"] if is_create else [],
+            "test_paths": [f"tests/test_{table}_migration.py"] if want_test else [],
         }
 
     if target == "middleware":
@@ -1862,6 +1887,12 @@ def _gen_migration(name: str, flags: dict = None, *,
     # snapshotted timestamp; if it was supplied via the private `_timestamp`
     # flag, honour it so envelope and disk agree byte-for-byte.
     timestamp = flags.get("_timestamp") or now.strftime("%Y%m%d%H%M%S")
+    # Private `_no_test` marker (set by `migrate:create`, which is a
+    # single-file operation): suppress the co-emitted test regardless of the
+    # keyword default. `_resolve_generation` reads the same marker so the
+    # envelope's `test_paths[]` and the on-disk effect stay in agreement.
+    if flags.get("_no_test"):
+        emit_test = False
     target = Path("migrations")
     target.mkdir(parents=True, exist_ok=True)
 

{tina4_python-3.13.120 → tina4_python-3.13.121}/tina4_python/mcp/tools.py

@@ -506,28 +506,63 @@ def register_dev_tools(server):
         return status(db)
 
     def migration_create(description: str) -> dict:
-        """Create a new migration file. Refuses to create a duplicate
-        for a description whose slug already exists in migrations/ —
-        the AI gets an error pointing at the existing file so it can
-        edit that one rather than spawning a second migration for the
-        same schema change."""
-        from tina4_python.migration import create_migration
+        """Create a new migration file AND return the ADR-0063 `generate_v1_1`
+        envelope so an agent gets the SAME edit_hints[]/next[] guidance a CLI
+        user gets.
+
+        Delegates to the same resolution-aware code path the CLI's
+        `tina4python migrate:create` / `tina4python generate migration` uses.
+        The private `_no_test` flag matches the migrate:create contract (no
+        co-emitted test file — a migration is a single-file operation).
+
+        Refuses to create a duplicate for a description whose slug already
+        exists in migrations/ — returns `{"ok": False, "existing": [...]}`
+        so the AI edits the existing file instead of spawning a second
+        migration for the same schema change. On collision the envelope is
+        NOT emitted (the operation did not run).
+
+        Return shape (MCP wire contract):
+            {"ok": True, "created": "<relative-path>", "resolution": <envelope>}
+                — success. `created` is the primary UP file path (preserves
+                the historical MCP field). `resolution` is the full CLI
+                envelope with `command`, `target`, `input`, nested
+                `resolution` (edit_hints + next + file_path), actions_taken,
+                dry_run.
+            {"ok": False, "error": "...", "existing": [...]}
+                — refused collision. No file was written. Envelope omitted.
+        """
+        import contextlib
+        import io
         import re as _re
+        from datetime import datetime as _dt
+
+        # Slug the description before delegating so the on-disk filename is
+        # well-formed even when the caller passed a natural-language phrase
+        # ("add users"). Matches the historical `create_migration()` behaviour
+        # this tool used to delegate to.
         slug = _re.sub(r"[^a-z0-9]+", "_", (description or "").lower()).strip("_")
+        if not slug:
+            return {
+                "ok": False,
+                "error": "description is empty; provide a short snake_case name",
+            }
+
         mig_dir = project_root / "migrations"
-        if mig_dir.is_dir() and slug:
-            # Compare against existing migration slugs (strip the
-            # leading timestamp and .sql/.down.sql extension). Reuse
-            # if an exact slug OR a clearly-equivalent slug exists.
+        if mig_dir.is_dir():
+            # Compare against existing migration slugs (strip the leading
+            # timestamp and .sql/.down.sql extension). Reuse if an exact
+            # slug OR a clearly-equivalent slug exists.
             existing: list[str] = []
             for p in sorted(mig_dir.glob("*.sql")):
-                name = p.name
+                fname = p.name
                 # Files look like "20260417175842_create_contact_messages_table.sql".
                 # Strip the timestamp prefix (14 digits + underscore) and the suffix.
-                after = _re.sub(r"^\d{14}_", "", name)
+                after = _re.sub(r"^\d{14}_", "", fname)
                 after = _re.sub(r"\.(down\.)?sql$", "", after)
                 existing_slug = _re.sub(r"[^a-z0-9]+", "_", after.lower()).strip("_")
-                if existing_slug == slug or existing_slug == slug + "_table" or slug == existing_slug + "_table":
+                if (existing_slug == slug
+                        or existing_slug == slug + "_table"
+                        or slug == existing_slug + "_table"):
                     existing.append(str(p.relative_to(project_root)))
             if existing:
                 return {
@@ -538,9 +573,52 @@ def register_dev_tools(server):
                     ),
                     "existing": existing,
                 }
-        filename = create_migration(description)
+
+        # Delegate to the same resolution-aware helpers the CLI uses so both
+        # surfaces produce byte-for-byte equivalent envelopes (modulo timestamp
+        # + file paths). Imported lazily to avoid pulling the CLI into every
+        # MCP tool-registration path.
+        from tina4_python.cli import (
+            _actions_from_resolution,
+            _gen_migration,
+            _hint_paths_from_resolution,
+            _input_fields,
+            _next_steps_for,
+            _resolve_generation,
+            _scan_edit_hints,
+        )
+
+        flags = {"_no_test": True}
+        # Lock the timestamp so `resolution.file_path` and the on-disk filename
+        # agree byte-for-byte (threaded to `_gen_migration` via `_timestamp`).
+        timestamp = _dt.now().strftime("%Y%m%d%H%M%S")
+        resolution = _resolve_generation("migration", slug, flags, timestamp=timestamp)
+
+        generator_flags = dict(flags)
+        generator_flags["_timestamp"] = timestamp
+        # Swallow the generator's own "  ✓ Created …" prints — MCP returns
+        # JSON to the caller, never text on stdout.
+        with contextlib.redirect_stdout(io.StringIO()):
+            _gen_migration(slug, generator_flags)
+
+        actions_taken = _actions_from_resolution("migration", resolution)
+        hint_paths = _hint_paths_from_resolution("migration", resolution)
+        edit_hints = _scan_edit_hints(project_root, hint_paths)
+        next_steps = _next_steps_for("migration", slug, resolution, flags)
+        resolution["edit_hints"] = edit_hints
+        resolution["next"] = next_steps
+
+        envelope = {
+            "command": "generate",
+            "target": "migration",
+            "input": {"name": slug, "fields": _input_fields(flags)},
+            "resolution": resolution,
+            "actions_taken": actions_taken,
+            "dry_run": False,
+        }
+        filename = resolution["file_path"]  # "migrations/{ts}_{slug}.sql"
         _record_plan_action("migration", filename, note=description)
-        return {"created": filename}
+        return {"ok": True, "created": filename, "resolution": envelope}
 
     def _record_plan_action(action: str, path: str, note: str = "") -> None:
         """Forward a file event to the active plan's execution ledger.