tina4-python 3.13.7__tar.gz → 3.13.9__tar.gz

{tina4_python-3.13.7 → tina4_python-3.13.9}/PKG-INFO

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

{tina4_python-3.13.7 → tina4_python-3.13.9}/pyproject.toml

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

{tina4_python-3.13.7 → tina4_python-3.13.9}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.7"
+__version__ = "3.13.9"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.7 → tina4_python-3.13.9}/tina4_python/ai/__init__.py

@@ -161,6 +161,136 @@ def install_context(root: str = ".", tools: "list[str] | None" = None) -> list[s
     return install_selected(root, selection)
 
 
+# ── v3.13.9: non-destructive context-file writer ───────────────────────────
+#
+# Pre-v3.13.9 the installer wrote a full developer guide to CLAUDE.md
+# (and the other context files) on every run, clobbering whatever the
+# user had put there. Now it writes only a marker-bracketed Tina4 skill
+# block — pointing the assistant at .claude/skills/tina4-*/SKILL.md —
+# and leaves the rest of the file alone.
+
+
+def _markers_for(context_file: str) -> "tuple[str, str]":
+    """Return ``(start_marker, end_marker)`` for a context file.
+
+    Markdown files get HTML comment markers (invisible when rendered).
+    Rule files (.cursorules, .windsurfrules, .clinerules) use ``#``
+    line comments which most rule loaders treat as comments.
+    """
+    if context_file.lower().endswith(".md"):
+        return ("<!-- tina4-skills:start -->", "<!-- tina4-skills:end -->")
+    return ("# tina4-skills:start", "# tina4-skills:end")
+
+
+def _skill_block(context_file: str) -> str:
+    """Return the marker-bracketed Tina4 skill registration block."""
+    start, end = _markers_for(context_file)
+    if context_file.lower().endswith(".md"):
+        body = (
+            "## Tina4 Skills\n\n"
+            "When working on this Tina4 project, these skills give the "
+            "assistant project-aware behaviour:\n\n"
+            "- **tina4-developer** — Read `.claude/skills/tina4-developer/SKILL.md` before building features.\n"
+            "- **tina4-js** — Read `.claude/skills/tina4-js/SKILL.md` for frontend work.\n"
+            "- **tina4-maintainer** — Read `.claude/skills/tina4-maintainer/SKILL.md` for framework-level changes.\n\n"
+            "See https://tina4.com for full docs."
+        )
+    else:
+        body = (
+            "Tina4 Skills — read these files before working on this project:\n"
+            "  .claude/skills/tina4-developer/SKILL.md   (feature development)\n"
+            "  .claude/skills/tina4-js/SKILL.md          (frontend / tina4-js)\n"
+            "  .claude/skills/tina4-maintainer/SKILL.md  (framework-level changes)\n"
+            "Docs: https://tina4.com"
+        )
+    return f"{start}\n{body}\n{end}"
+
+
+def _has_markers(existing: str, start: str, end: str) -> bool:
+    """True iff both start and end markers appear in order."""
+    s_idx = existing.find(start)
+    if s_idx == -1:
+        return False
+    return existing.find(end, s_idx + len(start)) != -1
+
+
+def _replace_marker_block(existing: str, block: str, start: str, end: str) -> str:
+    """Replace the bracketed block in ``existing`` with ``block``."""
+    s_idx = existing.find(start)
+    if s_idx == -1:
+        return existing.rstrip() + "\n\n" + block + "\n"
+    e_idx = existing.find(end, s_idx + len(start))
+    if e_idx == -1:
+        return existing.rstrip() + "\n\n" + block + "\n"
+    before = existing[:s_idx].rstrip()
+    after = existing[e_idx + len(end):].lstrip("\n")
+    glue_before = "\n\n" if before else ""
+    glue_after = "\n" + after if after else "\n"
+    return f"{before}{glue_before}{block}{glue_after}"
+
+
+# Headers the pre-v3.13.9 installer wrote at the top of CLAUDE.md.
+# Detecting these lets us migrate cleanly off the old clobber install.
+_OLD_FRAMEWORK_HEADERS = (
+    "# Tina4 Python",
+    "# Tina4 PHP",
+    "# Tina4 Ruby",
+    "# CLAUDE.md — AI Developer Guide for tina4-nodejs",
+    "# CLAUDE.md - AI Developer Guide for tina4-nodejs",
+)
+
+
+def _looks_like_old_framework_install(existing: str) -> bool:
+    """True if the file starts with a header the pre-v3.13.9 installer
+    wrote. Used to migrate one-time off the old clobber-style install."""
+    head = existing.lstrip()[:400]
+    return any(head.startswith(m) for m in _OLD_FRAMEWORK_HEADERS)
+
+
+def _write_or_merge(context_path: "Path", context_file: str, framework_guide: str) -> str:
+    """Write the context file non-destructively. Returns a human-readable
+    action verb for the caller's log line.
+
+    Four branches:
+      1. Doesn't exist  → write framework guide + skill block
+      2. Has markers    → refresh just the skill block (idempotent)
+      3. Old header     → migrate: replace old dump with new guide + block
+      4. User content   → append the skill block, preserve everything else
+    """
+    block = _skill_block(context_file)
+    start, end = _markers_for(context_file)
+
+    if not context_path.exists():
+        context_path.write_text(
+            framework_guide.rstrip() + "\n\n" + block + "\n",
+            encoding="utf-8",
+        )
+        return "Installed"
+
+    existing = context_path.read_text(encoding="utf-8")
+    if _has_markers(existing, start, end):
+        new_content = _replace_marker_block(existing, block, start, end)
+        context_path.write_text(new_content, encoding="utf-8")
+        return "Refreshed skill block in"
+
+    if _looks_like_old_framework_install(existing):
+        head = existing.lstrip()
+        preamble = existing[: len(existing) - len(head)]
+        new_content = (
+            (preamble.rstrip() + "\n\n" if preamble.strip() else "")
+            + framework_guide.rstrip()
+            + "\n\n"
+            + block
+            + "\n"
+        )
+        context_path.write_text(new_content, encoding="utf-8")
+        return "Migrated (replaced old framework dump in)"
+
+    new_content = existing.rstrip() + "\n\n" + block + "\n"
+    context_path.write_text(new_content, encoding="utf-8")
+    return "Appended skill block to"
+
+
 def _install_for_tool(root: Path, tool: dict, context: str) -> list[str]:
     """Install context file for a single tool."""
     created = []
@@ -171,9 +301,8 @@ def _install_for_tool(root: Path, tool: dict, context: str) -> list[str]:
         (root / tool["config_dir"]).mkdir(parents=True, exist_ok=True)
     context_path.parent.mkdir(parents=True, exist_ok=True)
 
-    # Always overwrite — user chose to install
-    context_path.write_text(context, encoding="utf-8")
-    action = "Updated" if context_path.exists() else "Installed"
+    # v3.13.9: non-destructive write — see _write_or_merge below.
+    action = _write_or_merge(context_path, tool["context_file"], context)
     rel = str(context_path.relative_to(root))
     created.append(rel)
     try:

{tina4_python-3.13.7 → tina4_python-3.13.9}/tina4_python/database/postgres.py

@@ -49,6 +49,60 @@ class PostgreSQLAdapter(DatabaseAdapter):
         else:
             cursor.execute(sql)
 
+    def _heal_aborted_txn(self):
+        """Issue #46 follow-on (v3.13.8): pre-flight rollback if the
+        connection arrived in an aborted-transaction state.
+
+        v3.13.6 added auto-rollback inside :meth:`_on_query_error` — that
+        clears the abort *on* a failure the wrapper catches. But the
+        connection can still arrive poisoned from elsewhere:
+
+        - A boot-time query that failed before request handling started
+          (migration probe, ORM ``information_schema`` lookup, etc.)
+        - A failure inside an explicit transaction where the user owned
+          the rollback but never issued one
+        - A direct ``cursor.execute`` call in another adapter method
+          (e.g. the ``SELECT lastval()`` SAVEPOINT probe) that managed to
+          leave the txn dirty
+
+        In all those cases the *next* query — even one routed through
+        our wrapper — hits ``InFailedSqlTransaction`` immediately, and
+        the cascade message buries whatever the original cause was.
+
+        Healing fix: before executing, ask psycopg2 whether the
+        connection is in ``TRANSACTION_STATUS_INERROR`` and rollback if
+        so. Only when NOT inside an explicit transaction — explicit txns
+        stay under the caller's control.
+
+        Reported by Schalk (24rent) against v3.13.7.
+        """
+        if self._in_transaction or self._conn is None:
+            return
+        try:
+            import psycopg2.extensions as _ext
+            status = self._conn.info.transaction_status
+        except Exception:
+            return
+        if status != _ext.TRANSACTION_STATUS_INERROR:
+            return
+        try:
+            self._conn.rollback()
+        except Exception:
+            # If even the heal-rollback fails, fall through — the next
+            # cursor.execute will raise with the real psycopg2 error and
+            # _on_query_error will pick it up. Better than masking.
+            return
+        try:
+            from tina4_python.debug import Log
+            Log.warning(
+                "PostgreSQL connection arrived in aborted-transaction "
+                "state — issued pre-flight ROLLBACK so the next query "
+                "starts clean. Look back in the log for the original "
+                "PostgreSQL query failed entry."
+            )
+        except Exception:
+            pass
+
     def _exec_with_handling(self, cursor, sql: str, params=None):
         """Run a query through :meth:`_safe_execute` and surface failures.
 
@@ -59,18 +113,23 @@ class PostgreSQLAdapter(DatabaseAdapter):
         block``, *far* from the actual cause. Without framework-side
         logging, the original SQL + error never reach the user.
 
-        On failure this method:
+        This method:
 
-        1. Logs the original error via ``Log.error`` with SQL+params context
-        2. Stores it on ``self.last_error``
-        3. Auto-rollbacks when NOT inside an explicit transaction (so the
-           next caller gets a clean connection)
+        0. (v3.13.8) Pre-flight heal — if the connection arrived in an
+           aborted-transaction state from anywhere outside this wrapper,
+           rollback first so this query starts on a clean txn.
+        1. Logs failures via ``Log.error`` with SQL+params context
+        2. Stores them on ``self.last_error``
+        3. Auto-rollbacks on failure when NOT inside an explicit
+           transaction (so the next caller gets a clean connection)
         4. Re-raises so callers still see the failure
 
-        Inside an explicit transaction we do NOT rollback — the user owns
-        that transaction (could be running a SAVEPOINT/retry pattern). We
-        still log + store ``last_error`` so they can diagnose.
+        Inside an explicit transaction we do NOT auto-rollback — the
+        user owns that transaction (could be running a SAVEPOINT/retry
+        pattern). We still log + store ``last_error`` so they can
+        diagnose, and the heal step also defers to explicit txns.
         """
+        self._heal_aborted_txn()
         try:
             self._safe_execute(cursor, sql, params)
         except Exception as e:
@@ -208,6 +267,12 @@ class PostgreSQLAdapter(DatabaseAdapter):
 
         sql = self._translate_sql(sql)
 
+        # v3.13.8: heal first so the COUNT probe below doesn't open on a
+        # poisoned connection — the probe uses raw _safe_execute (it's
+        # allowed to fail without polluting last_error) so it bypasses
+        # _exec_with_handling's heal step.
+        self._heal_aborted_txn()
+
         cursor = self._conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
 
         # Count total rows
@@ -217,6 +282,14 @@ class PostgreSQLAdapter(DatabaseAdapter):
             total = cursor.fetchone()["cnt"]
         except Exception:
             total = 0
+            # If the probe failed because the connection arrived (or
+            # became) aborted, roll back so the real pagination query
+            # below sees a clean txn. Without this we'd cascade.
+            if not self._in_transaction and self._conn is not None:
+                try:
+                    self._conn.rollback()
+                except Exception:
+                    pass
 
         # Apply pagination — the real query, so use the error-handling
         # wrapper. The count probe above is best-effort and stays on