tina4-python 3.13.61__tar.gz → 3.13.63__tar.gz

{tina4_python-3.13.61 → tina4_python-3.13.63}/.gitignore

@@ -46,6 +46,10 @@ test_queue*.db
 /publish.sh
 /src/scss/
 /broken
+# Framework runtime artefacts under .tina4/ — the Context FTS5 index
+# (.tina4/context.db), agent.log, and file-write backups. Transient,
+# per-machine, never source-of-truth. Keep the whole dir out of git.
+/.tina4/
 # Framework runtime artefacts — BrokenTracker writes import-time and
 # route-time failure dumps here. They're transient (timestamped per
 # error) and contain stack traces, never source-of-truth content.

{tina4_python-3.13.61 → tina4_python-3.13.63}/PKG-INFO

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

{tina4_python-3.13.61 → tina4_python-3.13.63}/pyproject.toml

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

{tina4_python-3.13.61 → tina4_python-3.13.63}/tina4_python/__init__.py

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

tina4_python-3.13.63/tina4_python/context/__init__.py

@@ -0,0 +1,371 @@
+# Tina4Python
+#
+# Context — a native, zero-dependency code/doc grounding index.
+#
+# Lets a Tina4 app ground its own AI assistant on its own source, offline:
+# it walks the project, chunks code on def/class boundaries and docs as prose,
+# and answers keyword/fuzzy queries over a SQLite FTS5 index (Python stdlib
+# ``sqlite3`` — FTS5 + ``bm25()`` are built in, so NO new dependency).
+#
+# The retrieval core is a thin port of the proven slice of neemee
+# (longmem-harness: memory_systems.SqliteFTS + pipeline.retrieve's stable
+# source-over-tests / definition-first reorderings). It COMPLEMENTS the
+# ``api_*`` reflection tools: ``api_*`` is exact structural lookup, Context is
+# fuzzy/semantic FTS over source + docs.
+#
+#   from tina4_python.context import Context
+#   ctx = Context(".tina4/context.db")
+#   ctx.index_root("src")
+#   ctx.search("where is the auth token issued?", k=5)
+#   #  -> [{"path": "src/auth.py", "score": 2.31, "snippet": "..."}, ...]
+#
+# On-disk index defaults to ``.tina4/context.db`` (gitignored). Guards a
+# sqlite build without FTS5: if absent, the Context degrades to safe no-ops
+# rather than crashing the app.
+
+import os
+import re
+import sqlite3
+import threading
+from pathlib import Path
+
+from .chunker import (
+    chunk_code,
+    chunk_text,
+    fold,
+    light_stem,
+    terms,
+)
+
+__all__ = ["Context", "default_context", "existing_context"]
+
+# File classification — mirrors neemee's repo walk.
+CODE_EXTS = {".py", ".php", ".js", ".mjs", ".ts", ".rb",
+             ".pas", ".dpr", ".dpk", ".inc", ".dfm", ".fmx"}
+DOC_EXTS = {".md", ".txt", ".rst", ".twig", ".html"}
+# deploy/CLI/env answers live in config files, not sources — chunk as code
+# (line windows), since sentence chunking shreds YAML/Dockerfiles.
+CONFIG_EXTS = {".toml", ".yml", ".yaml"}
+SPECIAL_FILES = {"dockerfile", "makefile", "docker-compose.yml",
+                 "package.json", "composer.json",
+                 ".env.example", ".env.sample"}
+# Same dirs neemee skips, plus Tina4 runtime dirs that hold no source of truth
+# (our own index/backups, session blobs, logs).
+SKIP_DIRS = {".git", "__pycache__", "node_modules", "vendor", "dist",
+             "build", "coverage", ".idea", ".venv", "venv", ".pytest_cache",
+             ".tina4", "sessions", "logs"}
+
+# generic question/code vocabulary that never NAMES a symbol — kept small.
+_DEF_STOP = frozenset(
+    "the and what how does can which where when who why list all available "
+    "module class function functions method methods def get set new return "
+    "import from with that this are is was for into use used".split())
+
+# a chunk that DEFINES a queried symbol ('def get_token', 'class Widget')
+# should out-rank one that merely USES it. Matched against the folded body.
+_DEF_KW = r"(?:async def|def|class|function|fn|func|interface|trait)"
+
+
+def _fts5_supported() -> bool:
+    """True if this interpreter's sqlite3 was built with FTS5."""
+    try:
+        conn = sqlite3.connect(":memory:")
+        try:
+            conn.execute("CREATE VIRTUAL TABLE _probe USING fts5(x)")
+            return True
+        finally:
+            conn.close()
+    except sqlite3.OperationalError:
+        return False
+    except Exception:
+        return False
+
+
+class Context:
+    """A SQLite FTS5 index over a project's source + docs.
+
+    Methods:
+        index_path(file, label=None) -> int   upsert one file (delete-by-path,
+                                               re-chunk, insert); reindex-safe.
+        index_root(root)             -> int   walk a tree, index every eligible
+                                               file (skips vendor/build dirs).
+        search(query, k=5)           -> list  [{path, score, snippet}] ranked by
+                                               bm25() with source-over-tests +
+                                               definition-first reordering.
+    """
+
+    def __init__(self, path="./.tina4/context.db", fts5_check=None):
+        """``path`` is the on-disk index file (its parent dir is created).
+        ``fts5_check`` overrides FTS5 detection (used by tests to exercise the
+        graceful-degradation path); defaults to a real probe of this build.
+        """
+        self.path = str(path)
+        self._lock = threading.Lock()
+        self.conn = None
+        self.root = None            # set by index_root; reindex_file relabels against it
+        check = fts5_check or _fts5_supported
+        self.available = bool(check())
+        if not self.available:
+            return
+        parent = Path(self.path).parent
+        if str(parent) not in ("", "."):
+            parent.mkdir(parents=True, exist_ok=True)
+        # One connection shared across threads (the dev-MCP handler may run on
+        # a worker thread) with a lock serializing access — a same-thread-only
+        # connection would reject those calls outright.
+        self.conn = sqlite3.connect(self.path, check_same_thread=False)
+        self._ensure_table()
+
+    # ── FTS5 availability ───────────────────────────────────────
+    @classmethod
+    def fts5_available(cls) -> bool:
+        """Whether this Python's sqlite3 supports FTS5 (module-level probe)."""
+        return _fts5_supported()
+
+    # ── schema ──────────────────────────────────────────────────
+    def _ensure_table(self):
+        # `body` holds fold(text) so query/index tokenization is symmetric;
+        # `raw` (UNINDEXED) keeps the original text to return as a snippet;
+        # `path`/`cid` (UNINDEXED) are metadata used for upsert + citation.
+        self.conn.execute(
+            "CREATE VIRTUAL TABLE IF NOT EXISTS chunks "
+            "USING fts5(cid UNINDEXED, path UNINDEXED, raw UNINDEXED, body)"
+        )
+        self.conn.commit()
+
+    def reset(self):
+        """Drop and recreate the index (full rebuild starting point)."""
+        if not self.available:
+            return
+        with self._lock:
+            self.conn.execute("DROP TABLE IF EXISTS chunks")
+            self._ensure_table()
+
+    # ── indexing ────────────────────────────────────────────────
+    @staticmethod
+    def _chunks_for(label, text):
+        """(index, chunk_text) pairs — code files on def/class boundaries,
+        everything else (docs) as prose."""
+        ext = os.path.splitext(label)[1].lower()
+        special = os.path.basename(label).lower() in SPECIAL_FILES
+        if ext in CODE_EXTS or ext in CONFIG_EXTS or special:
+            return chunk_code(text, path=label)
+        return chunk_text(text)
+
+    def index_path(self, file, label=None) -> int:
+        """UPSERT one file into the index: delete this path's existing chunks,
+        re-chunk the current contents, insert. A single file save re-indexes
+        just that file (sub-100ms). ``label`` is the stored/citation path
+        (defaults to ``str(file)``) and MUST be stable across calls for the
+        same file so the delete targets the right rows. Returns rows inserted.
+        """
+        if not self.available:
+            return 0
+        stored = str(label) if label is not None else str(file)
+        try:
+            text = Path(file).read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            return 0
+        rows = [
+            (f"{stored}:{i}", stored, chunk, fold(chunk))
+            for i, chunk in self._chunks_for(stored, text)
+        ]
+        with self._lock:
+            self.conn.execute("DELETE FROM chunks WHERE path = ?", (stored,))
+            if rows:
+                self.conn.executemany(
+                    "INSERT INTO chunks(cid, path, raw, body) VALUES (?, ?, ?, ?)",
+                    rows,
+                )
+            self.conn.commit()
+        return len(rows)
+
+    @staticmethod
+    def _eligible(filename) -> bool:
+        """True if a file should be indexed (the per-file filter used by both
+        index_root and reindex_file). Directory skipping is handled separately."""
+        fn = filename.lower()
+        if fn.endswith(".min.js"):
+            return False
+        ext = os.path.splitext(fn)[1]
+        return (ext in CODE_EXTS or ext in DOC_EXTS or ext in CONFIG_EXTS
+                or fn in SPECIAL_FILES)
+
+    def index_root(self, root) -> int:
+        """Walk ``root``, indexing every eligible file (skips vendor/build/
+        runtime dirs). Paths are stored RELATIVE to ``root`` for clean
+        citations. Records ``root`` so reindex_file can relabel a changed file
+        consistently. Returns the total number of chunks inserted."""
+        if not self.available:
+            return 0
+        root = Path(root).resolve()
+        self.root = root
+        total = 0
+        for dirpath, dirnames, filenames in os.walk(root):
+            # prune skip-dirs and dotdirs in place
+            dirnames[:] = [d for d in dirnames
+                           if d not in SKIP_DIRS and not d.startswith(".")]
+            for fn in sorted(filenames):
+                if not self._eligible(fn):
+                    continue
+                full = Path(dirpath) / fn
+                rel = str(full.relative_to(root))
+                total += self.index_path(full, label=rel)
+        return total
+
+    def reindex_file(self, changed_path) -> int:
+        """Re-index a single changed file into the LIVE index — the hook the dev
+        WebSocket reload trigger (POST /__dev/api/reload) calls so code_search
+        tracks edits without a rebuild. Resolves ``changed_path`` against the
+        indexed root, then: outside root / under a skip-or-dot dir / ineligible
+        → skip (-1); deleted → drop its chunks (0); otherwise UPSERT (rows).
+        No-op (-1) until index_root has run (nothing to keep fresh yet)."""
+        if not self.available or self.root is None:
+            return -1
+        p = Path(changed_path)
+        if not p.is_absolute():
+            # the reload trigger reports paths relative to the project root (cwd
+            # during `tina4 serve`); the index root may be a subdir like src/.
+            p = Path.cwd() / changed_path
+        try:
+            rel = p.resolve().relative_to(self.root)
+        except (ValueError, OSError):
+            return -1                          # outside the indexed root
+        if set(rel.parts) & SKIP_DIRS or any(part.startswith(".") for part in rel.parts[:-1]):
+            return -1                          # under a skipped / dot dir
+        if not self._eligible(rel.name):
+            return -1
+        stored = str(rel)
+        if not p.exists():                     # deleted → drop its chunks
+            with self._lock:
+                self.conn.execute("DELETE FROM chunks WHERE path = ?", (stored,))
+                self.conn.commit()
+            return 0
+        return self.index_path(p, label=stored)
+
+    # ── query ───────────────────────────────────────────────────
+    def _match_expr(self, query):
+        """Build the FTS5 MATCH string: each folded query token (plus its
+        light stem) as a quoted OR term. Quoting keeps it injection-safe."""
+        toks = set()
+        for t in terms(query):
+            toks.add(t)
+            toks.add(light_stem(t))
+        toks.discard("")
+        if not toks:
+            return None, set()
+        expr = " OR ".join('"%s"' % t for t in sorted(toks))
+        return expr, toks
+
+    @staticmethod
+    def _is_testlike(path):
+        s = (path or "").lower()
+        return any(p in s for p in ("/test", "test/", "test_", "_test.",
+                                    ".test.", "/example", "example/"))
+
+    def _defines(self, folded_body, symbols):
+        if not symbols:
+            return False
+        pat = re.compile(
+            _DEF_KW + r"\s+(?:" + "|".join(re.escape(s) for s in symbols)
+            + r")(?![a-z0-9])")
+        return bool(pat.search(folded_body))
+
+    def search(self, query, k=5):
+        """Return the top-``k`` chunks as ``[{path, score, snippet}]``, ranked
+        by ``bm25()`` then reordered with two stable, proven passes:
+          - source-over-tests: a test that merely mentions a symbol sinks below
+            the source that defines it (skipped when the query is about tests);
+          - definition-first: a chunk that DEFINES a queried symbol rises above
+            chunks that only use it.
+        Score is a higher-is-better float (sqlite's bm25 sign flipped).
+        """
+        if not self.available:
+            return []
+        expr, _ = self._match_expr(query)
+        if expr is None:
+            return []
+        pool_n = max(k * 3, 15)
+        with self._lock:
+            rows = self.conn.execute(
+                "SELECT path, raw, body, bm25(chunks) AS s FROM chunks "
+                "WHERE chunks MATCH ? ORDER BY s LIMIT ?",
+                (expr, pool_n),
+            ).fetchall()
+        if not rows:
+            return []
+
+        # candidate symbol names from the query (drop generic vocab).
+        symbols = {t for t in terms(query) if len(t) >= 3 and t not in _DEF_STOP}
+        about_tests = "test" in query.lower()
+
+        def sort_key(item):
+            idx, (path, raw, body, s) = item
+            is_test = 1 if (not about_tests and self._is_testlike(path)) else 0
+            is_def = 0 if self._defines(body, symbols) else 1
+            return (is_test, is_def, idx)   # bm25 order (idx) breaks ties
+
+        ordered = sorted(enumerate(rows), key=sort_key)
+        out = []
+        for _, (path, raw, body, s) in ordered[:k]:
+            out.append({
+                "path": path,
+                "score": round(-float(s), 6),   # bm25: more negative = better
+                "snippet": self._snippet(raw),
+            })
+        return out
+
+    @staticmethod
+    def _snippet(raw, limit=280):
+        text = (raw or "").strip()
+        if len(text) <= limit:
+            return text
+        return text[:limit].rstrip() + " ..."
+
+    # ── misc ────────────────────────────────────────────────────
+    def count(self) -> int:
+        if not self.available:
+            return 0
+        with self._lock:
+            return self.conn.execute("SELECT count(*) FROM chunks").fetchone()[0]
+
+    def is_empty(self) -> bool:
+        return self.count() == 0
+
+    def close(self):
+        if self.conn is not None:
+            with self._lock:
+                self.conn.close()
+                self.conn = None
+
+
+# ── process-wide shared index ───────────────────────────────────
+# code_search (dev MCP) and the dev-reload reindex hook must share ONE index so
+# a saved file is immediately searchable. Keyed by resolved db path.
+_shared_contexts: dict = {}
+
+
+def _db_key(db=None) -> str:
+    return str((Path(db) if db else Path.cwd() / ".tina4" / "context.db").resolve())
+
+
+def default_context(root=None, db=None) -> "Context":
+    """Get (or create) the process-wide Context at ``db`` (default
+    ``<cwd>/.tina4/context.db``). If ``root`` is given and the index is empty,
+    builds it once. This is what code_search uses so the reload hook can keep
+    the SAME index fresh."""
+    key = _db_key(db)
+    ctx = _shared_contexts.get(key)
+    if ctx is None:
+        ctx = Context(key)
+        _shared_contexts[key] = ctx
+    if root is not None and ctx.available and ctx.is_empty():
+        ctx.index_root(root)
+    return ctx
+
+
+def existing_context(db=None):
+    """Return the already-created shared Context for ``db`` (or None). Used by
+    the reload hook so a file change reindexes an EXISTING index but never
+    creates one on its own (nothing to keep fresh until code_search runs)."""
+    return _shared_contexts.get(_db_key(db))

tina4_python-3.13.63/tina4_python/context/chunker.py

@@ -0,0 +1,120 @@
+# Tina4Python
+#
+# Text folding + chunking for the Context subsystem.
+#
+# A thin, idiomatic port of the proven slice of neemee's tokenizer/chunkers
+# (longmem-harness: pipeline.chunk_code / chunk_text, memory_systems.fold).
+# Pure stdlib — ``re``/``unicodedata`` only. Nothing here touches SQLite; it
+# produces the (folded body, raw text) pairs the FTS5 index stores.
+
+import re
+import unicodedata
+
+# join comma-grouped numbers ("24,601" -> "24601") and split camelCase
+# ("ForeignKeyField" -> "foreign key field") so a query token reaches a
+# code identifier. snake_case already splits for free at the tokenizer.
+_NUM_COMMA = re.compile(r"(?<=\d),(?=\d)")
+_CAMEL = re.compile(r"(?<=[a-z0-9])(?=[A-Z])")
+_WORD_RE = re.compile(r"[a-z0-9]+")
+
+# Sentence boundary = end punctuation FOLLOWED BY whitespace/EOL, or a newline.
+# NOT a bare '.', which would shred embedded code in prose ("db.fetch()" ->
+# "db. fetch()"). Intra-token dots (method calls, module paths) stay intact.
+_SENT = re.compile(r"(?<=[.!?])\s+|\n+")
+
+# Chunk boundaries across languages: python defs/classes/decorators, php/js
+# functions and methods, ts exports/interfaces, php traits, and Object Pascal
+# unit/type/routine headers (Delphi is case-insensitive, accept either case).
+_TOPLEVEL = re.compile(
+    r"^(async def |def |class |@\w"
+    r"|\s*(?:public |private |protected |static |final |abstract )*function \w"
+    r"|(?:export )?(?:default )?(?:abstract )?class "
+    r"|interface |trait "
+    r"|export (?:const|function|interface|type|async) "
+    r"|[Uu]nit |[Pp]rocedure |[Ff]unction |[Cc]onstructor |[Dd]estructor "
+    r"|[Tt]ype$)"
+)
+
+
+def fold(text: str) -> str:
+    """Lowercase, strip diacritics, join comma-grouped numbers, split camelCase.
+
+    Applied symmetrically to the indexed ``body`` and to query tokens so
+    matching is consistent: a query for ``field`` reaches ``IntegerField``.
+    """
+    text = _CAMEL.sub(" ", _NUM_COMMA.sub("", text)).lower()
+    return unicodedata.normalize("NFKD", text) \
+        .encode("ascii", "ignore").decode("ascii")
+
+
+def light_stem(token: str) -> str:
+    """Fold simple plurals: strip one trailing 's', never from ss/us/is
+    endings (class, status, axis). QUERY-side only — so ``fields`` in a
+    question also reaches ``Field`` definitions."""
+    if len(token) > 3 and token.endswith("s") and not token.endswith(("ss", "us", "is")):
+        return token[:-1]
+    return token
+
+
+def terms(text: str):
+    """Accent-folded lowercase alphanumeric tokens (digits kept)."""
+    return _WORD_RE.findall(fold(text))
+
+
+def _pack(segments, max_lines):
+    """Pack line-segments into chunks of at most ``max_lines`` lines,
+    hard-splitting any single oversized segment."""
+    chunks, cur = [], []
+    for seg in segments:
+        while len(seg) > max_lines:            # oversized segment: hard split
+            if cur:
+                chunks.append(cur)
+                cur = []
+            chunks.append(seg[:max_lines])
+            seg = seg[max_lines:]
+        if cur and len(cur) + len(seg) > max_lines:
+            chunks.append(cur)
+            cur = []
+        cur += seg
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+
+def chunk_code(text: str, path: str = "", max_lines: int = 60):
+    """Chunk source on top-level def/class/decorator boundaries (sentence
+    chunking shreds code). Segments are packed up to ``max_lines``, and every
+    chunk starts with a ``# file: <path>`` line so the path's tokens are
+    indexed — 'where is the router?' should match core/router.py by name.
+
+    Returns a list of ``(index, chunk_text)`` pairs.
+    """
+    lines = text.splitlines()
+    bounds = [i for i, ln in enumerate(lines) if _TOPLEVEL.match(ln)]
+    if not bounds or bounds[0] != 0:
+        bounds = [0] + bounds
+    segments = [lines[a:b] for a, b in zip(bounds, bounds[1:] + [len(lines)])]
+
+    header = f"# file: {path}" if path else None
+    out = []
+    for i, ch in enumerate(_pack(segments, max_lines)):
+        body = "\n".join(([header] if header else []) + ch)
+        out.append((i, body))
+    return out
+
+
+def chunk_text(text: str, max_words: int = 350):
+    """Chunk prose/docs into sentence-packed windows of at most ``max_words``
+    words. Returns a list of ``(index, chunk_text)`` pairs."""
+    sents = [s.strip() for s in _SENT.split(text) if s.strip()]
+    chunks, cur, cur_words = [], [], 0
+    for s in sents:
+        w = len(s.split())
+        if cur and cur_words + w > max_words:
+            chunks.append(" ".join(cur))
+            cur, cur_words = [], 0
+        cur.append(s)
+        cur_words += w
+    if cur:
+        chunks.append(" ".join(cur))
+    return list(enumerate(chunks))

{tina4_python-3.13.61 → tina4_python-3.13.63}/tina4_python/crud/__init__.py

@@ -21,8 +21,10 @@ Generated endpoints per model:
     PUT    /api/{table_name}/{id}  — update record by primary key
     DELETE /api/{table_name}/{id}  — delete record by primary key
 
-All write routes (POST/PUT/DELETE) are registered with noauth so they
-don't conflict with existing auth defaults. Add auth via middleware.
+Write routes (POST/PUT/DELETE) are SECURE BY DEFAULT — they require a valid
+token, matching Tina4's framework-wide default (the router gates writes unless a
+route is @noauth). Pass ``public=True`` to open them explicitly, e.g.
+``AutoCrud.register(Note, public=True)``.
 """
 import importlib
 import inspect
@@ -66,12 +68,15 @@ class AutoCrud:
         return example
 
     @staticmethod
-    def register(model_class, prefix: str = "/api"):
+    def register(model_class, prefix: str = "/api", public: bool = False):
         """Register REST endpoints for a single ORM model class.
 
         Args:
             model_class: An ORM subclass with table_name and fields defined.
             prefix: URL prefix for the generated routes (default "/api").
+            public: If True, the write routes (POST/PUT/DELETE) are OPEN (no auth).
+                Default False keeps them **secure-by-default** — a valid token is
+                required, matching the framework's write-gating.
 
         Returns:
             List of dicts describing the generated routes.
@@ -168,7 +173,8 @@ class AutoCrud:
 
         create_handler.__name__ = f"autocrud_create_{table}"
         create_handler.__qualname__ = f"autocrud_create_{table}"
-        create_handler._noauth = True
+        if public:                       # secure-by-default; opt-in to public writes
+            create_handler._noauth = True
         create_handler._swagger_summary = f"Create {pretty_name}"
         create_handler._swagger_tags = [table]
         create_handler._swagger_example = example_body
@@ -201,7 +207,8 @@ class AutoCrud:
 
         update_handler.__name__ = f"autocrud_update_{table}"
         update_handler.__qualname__ = f"autocrud_update_{table}"
-        update_handler._noauth = True
+        if public:
+            update_handler._noauth = True
         update_handler._swagger_summary = f"Update {pretty_name}"
         update_handler._swagger_tags = [table]
         update_handler._swagger_example = example_body
@@ -224,7 +231,8 @@ class AutoCrud:
 
         delete_handler.__name__ = f"autocrud_delete_{table}"
         delete_handler.__qualname__ = f"autocrud_delete_{table}"
-        delete_handler._noauth = True
+        if public:
+            delete_handler._noauth = True
         delete_handler._swagger_summary = f"Delete {pretty_name}"
         delete_handler._swagger_tags = [table]
         Router.add("DELETE", f"{base_path}/{{id}}", delete_handler)
@@ -237,7 +245,7 @@ class AutoCrud:
         return generated
 
     @staticmethod
-    def discover(models_dir: str = "src/orm", prefix: str = "/api"):
+    def discover(models_dir: str = "src/orm", prefix: str = "/api", public: bool = False):
         """Auto-discover all ORM models in a directory and register CRUD routes.
 
         Scans .py files in the given directory, imports them, and registers
@@ -308,7 +316,7 @@ class AutoCrud:
                     and attr._get_table()  # Has a table name
                     and attr._get_table() not in AutoCrud._registered
                 ):
-                    AutoCrud.register(attr, prefix=prefix)
+                    AutoCrud.register(attr, prefix=prefix, public=public)
                     discovered.append(attr.__name__)
 
         if discovered:

{tina4_python-3.13.61 → tina4_python-3.13.63}/tina4_python/dev_admin/__init__.py

@@ -2000,6 +2000,19 @@ async def _api_reload(request, response):
     except Exception as e:
         Log.error(f"Re-discover on reload failed: {e}")
 
+    # Keep the code Context index LIVE on the same WebSocket-reload trigger:
+    # reindex just the changed file (UPSERT) so the dev-MCP code_search reflects
+    # the edit immediately. Only touches an already-built index (existing_context
+    # never creates one); guarded so a context failure never breaks the reload.
+    try:
+        if _reload_file[0]:
+            from tina4_python.context import existing_context
+            _ctx = existing_context()
+            if _ctx is not None:
+                _ctx.reindex_file(_reload_file[0])
+    except Exception as e:
+        Log.error(f"Context reindex on reload failed: {e}")
+
     # WebSocket-primary reload: push an instant message to every browser
     # connected on /__dev_reload. The toolbar client (and the dev-admin
     # dashboard) act on this immediately — the mtime poll above is only a