MetaList 0.22.0__tar.gz → 0.23.0__tar.gz

{metalist-0.22.0/metalist.egg-info → metalist-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.22.0
+Version: 0.23.0
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://metalist.app
 Project-URL: Repository, https://github.com/metalist-app/metalist
@@ -36,7 +36,7 @@ Provides-Extra: dev
 Requires-Dist: hypothesis==6.164.0; extra == "dev"
 Requires-Dist: pytest==9.1.1; extra == "dev"
 Requires-Dist: pytest-cov==7.1.0; extra == "dev"
-Requires-Dist: shockharness==0.17.0; extra == "dev"
+Requires-Dist: shockharness==0.26.0; extra == "dev"
 Requires-Dist: mypy==2.4.0; extra == "dev"
 
 # MetaList
@@ -53,6 +53,21 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.23.0
+
+- **Reference views.** Following a reference (a link, an embed's reference icon, Go to Source Note) or an AI answer's references slides the list to the left, and a gray chip takes the search box's place: **Source note** (its first line is the tooltip), **Reference** or **All references**. `←` or Escape goes back one level, `×` straight back to your search, each to the exact place you left; the list slides back to the right. With Reduce Motion it is a quick fade. The magnifier beside the chip starts a new search. Reference tabs keep their label and chip after a reload and in every window: no tab is named by a note ID any more.
+- One reference icon, a page with an arrow coming into it, on embeds, links, the chip, the tab list and the right-click menu's **Go to Source Note**; All references has two pages. A collapsed embed shows its source's first line in its own formatting (a green heading stays a green heading), and embeds are a shade darker grey, deeper again for an embed inside an embed.
+- Sort orders and Untagged show as chips inside the search box (`Created`, `Updated`, `A–Z`, `Size`, `Untagged`; the full name is the tooltip). New **Reverse Order** in Sort by works with any order: Z to A, oldest or smallest first, or your own order bottom to top. Typing a new search or leaving a tab ends its sort; a new tab starts unsorted; a reference view and back keeps it.
+- Right-clicking the list offers **Paste Note as Reference at Top** (⌘R) beside Paste Note at Top.
+- Backlinks (`↖`) are hidden for now, until they have a sign of their own.
+- Coming back to a tab, or from a reference view, lands exactly where you were; a note just below the top could put you up to 80px further down.
+- **Find in the list** (Cmd/Ctrl+F) finds text far below the loaded notes and inside folded ones; a folded match opens just for the find.
+- Namespaces are called **vaults** on screen; `--vault` works like `--namespace`.
+- Edit tag relationships: suggestions list tags linked to the focus tag first, a condition shows one part per line, and with no focus tag the `+` buttons are dimmed instead of stopping MetaList.
+- A file link downloads only from its badge and name; a click beside it edits the note.
+- Make Bigger, Make Smaller and Reset Size keep the caret on its side of the image.
+- Logging out while a log entry was being written could close the log under it; the logout now waits.
+
 ## Changes in 0.22.0
 
 - Tag suggestions only narrow as you type, however many letters: `q`, `qu`, `que` keep their order, and a tag that already applies (a parent's, or implied by a rule) stays right after the tags with evidence instead of dropping to the bottom. Each letter after the first answers in a few milliseconds. Measured on a 107,000-note namespace, the wanted tag is in the top five more often after two and three letters (90% and 96%, up from 88% and 93%).

{metalist-0.22.0 → metalist-0.23.0}/README.md

@@ -12,6 +12,21 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.23.0
+
+- **Reference views.** Following a reference (a link, an embed's reference icon, Go to Source Note) or an AI answer's references slides the list to the left, and a gray chip takes the search box's place: **Source note** (its first line is the tooltip), **Reference** or **All references**. `←` or Escape goes back one level, `×` straight back to your search, each to the exact place you left; the list slides back to the right. With Reduce Motion it is a quick fade. The magnifier beside the chip starts a new search. Reference tabs keep their label and chip after a reload and in every window: no tab is named by a note ID any more.
+- One reference icon, a page with an arrow coming into it, on embeds, links, the chip, the tab list and the right-click menu's **Go to Source Note**; All references has two pages. A collapsed embed shows its source's first line in its own formatting (a green heading stays a green heading), and embeds are a shade darker grey, deeper again for an embed inside an embed.
+- Sort orders and Untagged show as chips inside the search box (`Created`, `Updated`, `A–Z`, `Size`, `Untagged`; the full name is the tooltip). New **Reverse Order** in Sort by works with any order: Z to A, oldest or smallest first, or your own order bottom to top. Typing a new search or leaving a tab ends its sort; a new tab starts unsorted; a reference view and back keeps it.
+- Right-clicking the list offers **Paste Note as Reference at Top** (⌘R) beside Paste Note at Top.
+- Backlinks (`↖`) are hidden for now, until they have a sign of their own.
+- Coming back to a tab, or from a reference view, lands exactly where you were; a note just below the top could put you up to 80px further down.
+- **Find in the list** (Cmd/Ctrl+F) finds text far below the loaded notes and inside folded ones; a folded match opens just for the find.
+- Namespaces are called **vaults** on screen; `--vault` works like `--namespace`.
+- Edit tag relationships: suggestions list tags linked to the focus tag first, a condition shows one part per line, and with no focus tag the `+` buttons are dimmed instead of stopping MetaList.
+- A file link downloads only from its badge and name; a click beside it edits the note.
+- Make Bigger, Make Smaller and Reset Size keep the caret on its side of the image.
+- Logging out while a log entry was being written could close the log under it; the logout now waits.
+
 ## Changes in 0.22.0
 
 - Tag suggestions only narrow as you type, however many letters: `q`, `qu`, `que` keep their order, and a tag that already applies (a parent's, or implied by a rule) stays right after the tags with evidence instead of dropping to the bottom. Each letter after the first answers in a few milliseconds. Measured on a 107,000-note namespace, the wanted tag is in the top five more often after two and three letters (90% and 96%, up from 88% and 93%).

{metalist-0.22.0 → metalist-0.23.0}/app/api/note_requests.py

@@ -56,18 +56,26 @@ class Viewport(TypedDict):
     scrollY: Nonnegative
     scrollAnchor: ScrollAnchor | None
 
+# A root sort order, and the same order reversed (app/services/root_sorting.py).
+SortMode = Literal[
+    'normal', 'created', 'updated', 'alphabetical', 'content-volume',
+    'normal-reversed', 'created-reversed', 'updated-reversed', 'alphabetical-reversed', 'content-volume-reversed',
+]
+
 @with_config(ConfigDict(strict=True))
 class Tab(TypedDict):
     searchQuery: Text
     scrollY: Nonnegative
     anchorRootId: Text | None
     scrollAnchor: ScrollAnchor | None
-    sortMode: Literal['normal', 'created', 'updated', 'alphabetical', 'content-volume']
+    sortMode: SortMode
 
 @with_config(ConfigDict(strict=True))
 class ViewDiffRequest(TypedDict):
     clientId: Identifier
     editingNoteId: Text | None
+    # The note find opened to show a match folded away, for this view only (docs/ui/find.md).
+    findRevealNoteId: Text | None
     search: Text | None
     tabId: Identifier
     undoContext: UndoContext
@@ -77,16 +85,42 @@ class ViewDiffRequest(TypedDict):
     isUntaggedView: bool
     startAtListEnd: bool
 
+# Find in the list (docs/ui/find.md): one step from a root position of the view.
+@with_config(ConfigDict(strict=True))
+class FindInListRequest(TypedDict):
+    tabId: Identifier
+    search: Text | None
+    isUntaggedView: bool
+    text: Annotated[str, Field(min_length=1, max_length=KIB)]
+    fromRootIndex: Nonnegative
+    direction: Literal['forward', 'backward']
+
+@with_config(ConfigDict(strict=True))
+class ReferenceOriginScope(TypedDict):
+    scopeTabId: Identifier
+    searchQuery: Text
+    sortMode: SortMode
+    isUntaggedView: bool
+
+# A tab showing a reference view, opened from another tab (app/services/tab_state.py).
+@with_config(ConfigDict(strict=True))
+class ReferenceView(TypedDict):
+    fromTabId: Identifier
+    referenceQuery: Text
+    viewKind: Literal['source', 'backlinks', 'reference', 'references']
+    originScope: ReferenceOriginScope
+
 @with_config(ConfigDict(strict=True))
 class UpdateTabStateRequest(TypedDict):
     activeTabId: Identifier
     tabs: dict[Identifier, Tab]
     tabOrder: list[Identifier]
+    referenceViews: dict[Identifier, ReferenceView]
 
 @with_config(ConfigDict(strict=True))
 class UpdateTabSortModeRequest(TypedDict):
     tabId: Identifier
-    sortMode: Literal['normal', 'created', 'updated', 'alphabetical', 'content-volume']
+    sortMode: SortMode
     clientId: Identifier
     undoContext: UndoContext
 
@@ -126,7 +160,7 @@ class TabSearchInteractionRequest(TypedDict):
 class DictationPasteRequest(TypedDict):
     """Text pasted into the search bar or the tag bar, and the field's current value."""
     text: Text
-    target: Literal["search", "tags", "tag", "condition"]
+    target: Literal["search", "tags", "tag"]
     current_value: Text
     # The spoken phrases around a quoted phrase (Dictation Settings).
     quote_open: Identifier

{metalist-0.22.0 → metalist-0.23.0}/app/api/routes/auth.py

@@ -1024,7 +1024,7 @@ def namespace_delete_job_status(
         exc = job_record_capture.captured_exception
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail=str(exc)) from exc
     if job_record is None:
-        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail=f"Namespace deletion job not found: {job_id}")
+        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail=f"Vault deletion job not found: {job_id}")
     return job_record
 
 
@@ -1038,7 +1038,7 @@ def namespace_rename_job_status(job_id: str):
         exc = job_record_capture.captured_exception
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail=str(exc)) from exc
     if job_record is None:
-        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail=f"Namespace rename job not found: {job_id}")
+        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail=f"Vault rename job not found: {job_id}")
     return job_record
 
 

{metalist-0.22.0 → metalist-0.23.0}/app/api/routes/backups.py

@@ -301,7 +301,7 @@ def _normalize_selected_namespaces(*, selected_namespaces: list[str]) -> list[st
         raise TypeError("selected_namespaces must be a list")
     normalized_selected_namespaces = _order_namespaces(namespaces=selected_namespaces)
     if len(normalized_selected_namespaces) == 0:
-        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Select at least one namespace to back up")
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Select at least one vault to back up")
     return normalized_selected_namespaces
 
 
@@ -310,7 +310,7 @@ def _require_existing_selected_namespaces(*, selected_namespaces: list[str]) ->
     for namespace in normalized_selected_namespaces:
         database_path = resolve_namespaced_database_path(namespace=namespace)
         if not database_path.is_file():
-            raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail=f"Selected namespace has no database yet: {namespace}")
+            raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail=f"Selected vault has no database yet: {namespace}")
     return normalized_selected_namespaces
 
 
@@ -324,7 +324,7 @@ def _filter_deleted_selected_namespaces(*, selected_namespaces: list[str]) -> li
     if len(existing_selected_namespaces) == 0:
         raise HTTPException(
             status_code=HTTPStatus.BAD_REQUEST,
-            detail="None of the selected backup namespaces still exist",
+            detail="None of the selected backup vaults still exist",
         )
     return existing_selected_namespaces
 
@@ -583,7 +583,7 @@ def _verify_target_namespace_password(*, target_namespace: str, password: str) -
     if not _target_auth_settings_have_password(settings=settings):
         return
     if password == "":
-        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Target namespace password is required")
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Target vault password is required")
 
     assert settings is not None
     auth_salt = settings["auth_salt"]
@@ -610,7 +610,7 @@ def _verify_target_namespace_password(*, target_namespace: str, password: str) -
         parallelism,
     ).hex()
     if not secrets.compare_digest(candidate, auth_verifier):
-        raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Target namespace password is incorrect")
+        raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Target vault password is incorrect")
 
 
 def _collect_import_profile_port_conflicts(
@@ -633,7 +633,7 @@ def _collect_import_profile_port_conflicts(
             continue
         conflict_namespace, conflict_service = occupied_ports[port]
         conflicts.append(
-            f"{service} port {port} conflicts with {conflict_service} port reserved for namespace {conflict_namespace}"
+            f"{service} port {port} conflicts with {conflict_service} port reserved for vault {conflict_namespace}"
         )
     return conflicts
 
@@ -959,7 +959,7 @@ def restore_backup_preflight(
 
     folder_namespace, folder_filename = _parse_folder_backup_id(payload.backup_id)
     if folder_namespace != backup_namespace:
-        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup namespace does not match payload")
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup vault does not match payload")
     if folder_filename != payload.backup_filename:
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup filename does not match payload")
     settings = load_backup_settings(token=token)
@@ -1030,7 +1030,7 @@ def restore_backup(
 
     folder_namespace, folder_filename = _parse_folder_backup_id(payload.backup_id)
     if folder_namespace != backup_namespace:
-        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup namespace does not match payload")
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup vault does not match payload")
     if folder_filename != payload.backup_filename:
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup filename does not match payload")
     settings = load_backup_settings(token=token)
@@ -1101,7 +1101,7 @@ def import_backup(
     if target_exists and not payload.overwrite_existing_target:
         raise HTTPException(
             status_code=HTTPStatus.CONFLICT,
-            detail=f"Target namespace already exists: {target_namespace}",
+            detail=f"Target vault already exists: {target_namespace}",
         )
     if target_exists:
         _verify_target_namespace_password(
@@ -1112,7 +1112,7 @@ def import_backup(
     target_database_path = resolve_namespaced_database_path(namespace=target_namespace)
     folder_namespace, folder_filename = _parse_folder_backup_id(payload.backup_id)
     if folder_namespace != backup_namespace:
-        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup namespace does not match payload")
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup vault does not match payload")
     if folder_filename != payload.backup_filename:
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="folder backup filename does not match payload")
     settings = load_backup_settings(token=token)

{metalist-0.22.0 → metalist-0.23.0}/app/api/routes/notes.py

@@ -11,6 +11,7 @@ from pydantic import BaseModel
 
 from app.api.note_requests import (
     ViewDiffRequest,
+    FindInListRequest,
     UpdateTabStateRequest,
     UpdateTabSortModeRequest,
     CreateNewTabRequest,
@@ -63,6 +64,7 @@ from app.api.note_requests import (
 from app.api.transactions import serialized_read_route, transactional_route
 from app.services.sync import touch_client
 from app.services.snapshot import build_view_state
+from app.services.snapshot import find_in_view
 from app.services.snapshot import resolve_search_scope
 from app.services.snapshot import resolve_view_scope_membership
 from app.services.note_store import store as note_store
@@ -300,6 +302,7 @@ def view_diff(payload: ViewDiffRequest):
     client_id = payload["clientId"]
     touch_client(client_id)
     editing_note_id = payload["editingNoteId"]
+    find_reveal_note_id = payload["findRevealNoteId"]
     search = payload["search"]
     tab_id = payload["tabId"]
     undo_context = payload["undoContext"]
@@ -341,6 +344,10 @@ def view_diff(payload: ViewDiffRequest):
         if not note_store.has_note(normalized_editing_note_id):
             normalized_editing_note_id = None
 
+    # Like editingNoteId, the note find opened can be gone by now (deleted, undone).
+    if find_reveal_note_id is not None and not note_store.has_note(find_reveal_note_id):
+        find_reveal_note_id = None
+
     # The server keeps each tab's warm view (what that browser tab displays),
     # so the browser sends only where it is. A tab with no warm view, or one
     # whose browser shows nothing for it, gets its initial window.
@@ -357,6 +364,7 @@ def view_diff(payload: ViewDiffRequest):
 
     state = build_view_state(
         editing_note_id=normalized_editing_note_id,
+        find_reveal_note_id=find_reveal_note_id,
         search=normalized_search,
         sort_mode=sort_mode,
         client_known_note_ids=client_known_note_ids,
@@ -414,17 +422,26 @@ def get_tab_state() -> Dict[str, object]:
 @router.post("/notes/tab-state")
 @transactional_route
 def update_tab_state(payload: UpdateTabStateRequest) -> Dict[str, object]:
-    if "activeTabId" not in payload or "tabs" not in payload or "tabOrder" not in payload:
-        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="activeTabId, tabs, and tabOrder are required")
+    if (
+        "activeTabId" not in payload or "tabs" not in payload or "tabOrder" not in payload
+        or "referenceViews" not in payload
+    ):
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST,
+            detail="activeTabId, tabs, tabOrder, and referenceViews are required",
+        )
     active_tab_id = payload["activeTabId"]
     tabs = payload["tabs"]
     tab_order = payload["tabOrder"]
+    reference_views = payload["referenceViews"]
     if not isinstance(tab_order, list):
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="tabOrder must be a list")
     tab_order_list = [str(entry) for entry in tab_order]
     capture = CapturedExceptionContext(InputRejected, boundary='app/api/routes/notes.py:update_tab_state:capture')
     with capture:
-        response = tab_state_store.update(active_tab_id=active_tab_id, tabs=tabs, tab_order=tab_order_list)
+        response = tab_state_store.update(
+            active_tab_id=active_tab_id, tabs=tabs, tab_order=tab_order_list, reference_views=reference_views,
+        )
     if capture.captured_exception is not None:
         raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="Invalid or stale tab state") from capture.captured_exception
     return response
@@ -632,6 +649,39 @@ def get_memory_usage(request: Request) -> Dict[str, object]:
     return describe_memory_usage()
 
 
+@router.post("/notes/find")
+@transactional_route
+def find_in_list(payload: FindInListRequest) -> Dict[str, object]:
+    """One step of find through the list a tab shows (docs/ui/find.md): the notes the
+    text occurs in, in list order, from a root position forward or before it backward."""
+    search = payload["search"]
+    if search is None or search.strip() == "":
+        search = ""
+    else:
+        # A search that does not parse is answered as rejected input, as the view does.
+        parse_search_query(search)
+    if payload["text"].strip() == "":
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST, detail="text must hold more than spaces")
+    window = find_in_view(
+        find_text=payload["text"], search=search, sort_mode=_resolve_tab_sort_mode(payload["tabId"]),
+        is_untagged_view=payload["isUntaggedView"], from_root_index=payload["fromRootIndex"],
+        direction=payload["direction"],
+    )
+    return {
+        "matches": [
+            {
+                "noteId": match.note_id, "rootId": match.root_id, "rootIndex": match.root_index,
+                "contentCount": match.content_count, "commentCount": match.comment_count,
+                "previewCount": match.preview_count, "isUnderFoldedNote": match.is_under_folded_note,
+            }
+            for match in window.matches
+        ],
+        "firstRootIndex": window.first_root_index,
+        "endRootIndex": window.end_root_index,
+        "rootCount": window.root_count,
+    }
+
+
 @router.get("/notes/memory-usage/breakdown")
 @serialized_read_route
 def get_memory_breakdown(request: Request) -> Dict[str, object]:

{metalist-0.22.0 → metalist-0.23.0}/app/api/routes/ontology.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+from collections import Counter
+from dataclasses import dataclass
+
 from app.utils.byte_sizes import MIB
 from http import HTTPStatus
 from fastapi import APIRouter, HTTPException, Request
@@ -10,7 +13,12 @@ from pydantic import ConfigDict, Field, with_config
 
 from app.api.request_auth import get_request_auth_token
 from app.api.transactions import transactional_route
+from app.security.sensitive_cache import SensitiveMemo
+from app.services.resource_limits import SENSITIVE_MEMO_BYTES
 from app.services.search_index import search_index
+from app.services.tag_ontology import TagOntology
+from app.services.tag_term_matching import list_significant_content_match_segments
+from app.utils.not_found import NOT_FOUND
 from app.services.note_store import store as note_store
 from app.services.sync import generate_new_uuid
 from app.services.tag_ontology import RegexAtom, TagAtom, TextAtom, parse_rules_text
@@ -35,6 +43,15 @@ _EQUALITY_LINE_RULE_COUNT = 2
 _PREFIX_MATCH_RANK = 0
 _SUBSTRING_MATCH_RANK = 1
 _FUZZY_MATCH_RANK = 2
+# What a Tag Relationships field adds next to its focus tag; "none" ranks tags by use alone.
+_SUGGESTION_RELATIONS = frozenset({"none", "incoming", "implied", "synonym"})
+# A tag counts as linked to the focus tag once they share this many notes: one shared
+# note is chance.
+_MIN_SHARED_NOTES = 2
+# The focus tags whose related order is kept while their dialog is open (tag names
+# are private: the memo is cleared on lock).
+_RELATED_ORDER_MEMO_ENTRIES = 4
+_related_orders = SensitiveMemo(maxsize=_RELATED_ORDER_MEMO_ENTRIES, max_bytes=SENSITIVE_MEMO_BYTES)
 
 
 def _maybe_bearer_token(request: Request) -> str:
@@ -389,27 +406,27 @@ def focus_view(tag: str) -> dict:
     for candidate in sorted(left):
         if candidate in equals:
             continue
-        rule_ids: set[int] = set()
+        left_rule_ids: set[int] = set()
         for member in equals:
             key = (candidate, member)
             if key in edge_map:
-                rule_ids.add(edge_map[key])
-        if not rule_ids:
+                left_rule_ids.add(edge_map[key])
+        if not left_rule_ids:
             continue
-        direct_left.append({"tag": candidate, "ruleIds": sorted(rule_ids)})
+        direct_left.append({"tag": candidate, "ruleIds": sorted(left_rule_ids)})
 
     for candidate in sorted(right):
         if candidate in equals:
             continue
-        rule_ids: set[int] = set()
+        right_rule_ids: set[int] = set()
         for member in equals:
             key = (member, candidate)
             if key in edge_map:
-                rule_ids.add(edge_map[key])
-        if not rule_ids:
+                right_rule_ids.add(edge_map[key])
+        if not right_rule_ids:
             continue
         direct_right_tags.add(candidate)
-        direct_right.append({"tag": candidate, "ruleIds": sorted(rule_ids)})
+        direct_right.append({"tag": candidate, "ruleIds": sorted(right_rule_ids)})
 
     for candidate in sorted(equals):
         if candidate == tag:
@@ -442,53 +459,128 @@ def focus_view(tag: str) -> dict:
     }
 
 
+@dataclass(frozen=True)
+class _RelatedOrder:
+    """Tags in the order a Tag Relationships field suggests them for its focus tag: linked
+    tags first, then tags sharing a word with it, then the rest by use."""
+
+    index_revision: int
+    # Compared by identity: editing the rules compiles a new ontology.
+    ontology: TagOntology
+    linked: tuple[str, ...]
+    named_alike: tuple[str, ...]
+    by_use: tuple[str, ...]
+
+
+def _link_score(*, relation: str, shared: int, focus_notes: int, tag_notes: int) -> float:
+    """How strongly a tag is linked to the focus tag for `relation` (0 to 1)."""
+    assert 0 < shared <= tag_notes and shared <= focus_notes, (shared, tag_notes, focus_notes)
+    if relation == "incoming":
+        # tag => focus: how many of the tag's notes carry the focus tag.
+        return shared / tag_notes
+    if relation == "implied":
+        # focus => tag: how many of the focus tag's notes carry the tag.
+        return shared / focus_notes
+    assert relation == "synonym", relation
+    # Both ways: the notes they share among the notes either is on.
+    return shared / (focus_notes + tag_notes - shared)
+
+
+def _related_order(*, focus: str, relation: str, tag_counts: dict[str, int]) -> _RelatedOrder:
+    ontology = get_ontology()
+    key = (focus.casefold(), relation)
+    found, kept = _related_orders.lookup(key)
+    if found and kept.index_revision == search_index.revision and kept.ontology is ontology:
+        return kept
+    index_revision = search_index.revision
+    focus_notes, written_with_focus = search_index.count_written_tags_on_notes_with(focus)
+    left, equal, right = ontology.focus_view(tag=focus)
+    # The focus tag, its synonyms, and tags already on this side of it say nothing new.
+    excluded = {tag.casefold() for tag in equal} | {focus.casefold()}
+    if relation == "incoming":
+        excluded |= {tag.casefold() for tag in left}
+    elif relation == "implied":
+        excluded |= {tag.casefold() for tag in right}
+    candidates = [tag for tag in tag_counts if tag.casefold() not in excluded]
+    scored = []
+    for tag in candidates:
+        # A meta tag (@bold, @todo) is formatting or a state, not a topic linked to the
+        # focus tag; it is still listed by use, and when "@" is typed.
+        if tag.startswith("@") or tag.casefold() not in written_with_focus:
+            continue
+        tag_shared, tag_notes = written_with_focus[tag.casefold()]
+        if tag_shared >= _MIN_SHARED_NOTES:
+            score = _link_score(relation=relation, shared=tag_shared, focus_notes=focus_notes, tag_notes=tag_notes)
+            scored.append((-score, -tag_shared, tag.casefold(), tag))
+    linked = tuple(tag for *_ordering, tag in sorted(scored))
+    linked_set = set(linked)
+    focus_words = set(list_significant_content_match_segments(focus))
+    by_use_order = sorted((tag for tag in candidates if tag not in linked_set), key=lambda tag: (-tag_counts[tag], tag))
+    named_alike = tuple(tag for tag in by_use_order if focus_words & set(list_significant_content_match_segments(tag)))
+    named_alike_set = set(named_alike)
+    order = _RelatedOrder(
+        index_revision=index_revision, ontology=ontology, linked=linked, named_alike=named_alike,
+        by_use=tuple(tag for tag in by_use_order if tag not in named_alike_set),
+    )
+    _related_orders.store(key, order)
+    return order
+
+
+def _match_rank(*, needle: str, tag: str) -> int:
+    """How a typed text matches a tag (prefix, substring or fuzzy), NOT_FOUND if not at all."""
+    folded = tag.casefold()
+    if folded.startswith(needle):
+        return _PREFIX_MATCH_RANK
+    if needle in folded:
+        return _SUBSTRING_MATCH_RANK
+    if _fuzzy_match(needle, folded):
+        return _FUZZY_MATCH_RANK
+    return NOT_FOUND
+
+
 @router.get("/tags")
-def list_tags(q: str, limit: int) -> dict:
-    if not isinstance(q, str):
-        raise TypeError("q must be a string")
+def list_tags(q: str, limit: int, focus: str, relation: str) -> dict:
+    """Tags for a Tag Relationships field. With a `relation` to `focus`, tags linked to the
+    focus tag come first, then tags sharing a word with it, then the rest by use; typing
+    narrows that order (app/services/agent/skills/help-ontology.md, "Relationship dialogs"). Without one (`relation` "none",
+    `focus` ""), by match, then use."""
+    if not isinstance(q, str) or not isinstance(focus, str) or not isinstance(relation, str):
+        raise TypeError("q, focus and relation must be strings")
     if not isinstance(limit, int):
         raise TypeError("limit must be an int")
     if limit < 0:
         raise ValueError("limit must be >= 0")
+    if relation not in _SUGGESTION_RELATIONS:
+        raise ValueError(f"Unknown suggestion relation: {relation!r}")
+    if (relation == "none") != (focus == ""):
+        raise ValueError("A focus tag goes with a relation, and only with one")
 
     ontology = get_ontology()
     # A tag only the rules name is on no note yet.
     tag_counts = {tag: 0 for tag in extract_ontology_tags(ontology)}
     tag_counts.update(search_index.list_tag_frequencies())
-    tags = set(tag_counts.keys())
-
     needle = q.casefold().strip()
 
+    if relation != "none":
+        order = _related_order(focus=focus, relation=relation, tag_counts=tag_counts)
+        ordered: list[str] = []
+        for group in (order.linked, order.named_alike):
+            ordered.extend(tag for tag in group if needle == "" or _match_rank(needle=needle, tag=tag) != NOT_FOUND)
+        rest = [(_match_rank(needle=needle, tag=tag), index, tag) for index, tag in enumerate(order.by_use)]
+        ordered.extend(tag for rank, _index, tag in sorted(rest) if needle == "" or rank != NOT_FOUND)
+        payload = [{"tag": tag, "count": tag_counts[tag]} for tag in ordered[:limit]]
+        return {"totalCount": len(tag_counts), "tags": payload}
+
     if needle == "":
-        ordered = sorted(tags, key=lambda tag: (-tag_counts[tag], tag))
-        ordered = ordered[:limit]
-        payload = [
-            {"tag": tag, "count": tag_counts[tag]}
-            for tag in ordered
-        ]
-        return {"totalCount": len(tags), "tags": payload}
+        ordered = sorted(tag_counts, key=lambda tag: (-tag_counts[tag], tag))[:limit]
+        return {"totalCount": len(tag_counts), "tags": [{"tag": tag, "count": tag_counts[tag]} for tag in ordered]}
 
     matches: list[tuple[int, int, str]] = []
-    for tag in tags:
-        folded = tag.casefold()
-        if folded.startswith(needle):
-            rank = _PREFIX_MATCH_RANK
-        elif needle in folded:
-            rank = _SUBSTRING_MATCH_RANK
-        elif _fuzzy_match(needle, folded):
-            rank = _FUZZY_MATCH_RANK
-        else:
-            continue
-        count = tag_counts[tag]
-        matches.append((rank, -count, tag))
-
+    for tag in tag_counts:
+        rank = _match_rank(needle=needle, tag=tag)
+        if rank != NOT_FOUND:
+            matches.append((rank, -tag_counts[tag], tag))
     # By rank, then most used, then name.
     matches.sort()
-    results = [tag for _rank, _negative_count, tag in matches]
-    results = results[:limit]
-
-    payload = [
-        {"tag": tag, "count": tag_counts[tag]}
-        for tag in results
-    ]
-    return {"totalCount": len(tags), "tags": payload}
+    payload = [{"tag": tag, "count": tag_counts[tag]} for _rank, _negative_count, tag in matches[:limit]]
+    return {"totalCount": len(tag_counts), "tags": payload}

{metalist-0.22.0 → metalist-0.23.0}/app/api/transactions.py

@@ -86,7 +86,7 @@ def transactional_route(func: Callable[P, R] | Callable[P, Awaitable[R]]) -> Cal
                 _check_bulk_guard(func.__name__)
                 maintenance = nullcontext()
                 if func.__name__ in _STORAGE_TRANSITIONS:
-                    maintenance = maintenance_service.hold_for_transaction("Updating namespace storage")
+                    maintenance = maintenance_service.hold_for_transaction("Updating vault storage")
                 with maintenance:
                     with begin_request_transaction():
                         register_runtime_recovery()
@@ -147,7 +147,7 @@ def assert_mutation_routes_wrapped(app: FastAPI) -> None:
 
 def _check_bulk_guard(endpoint_name: str) -> None:
     if endpoint_name in _STORAGE_TRANSITIONS and bulk_operation_guard.active_mutations > 1:
-        raise HTTPException(status_code=HTTPStatus.CONFLICT, detail="Wait for the current request to finish before changing namespace storage.")
+        raise HTTPException(status_code=HTTPStatus.CONFLICT, detail="Wait for the current request to finish before changing vault storage.")
     # Preferences never touch notes, and every operation reads them once when it
     # starts, so saving them (e.g. the chat panel width) cannot disturb it.
     permitted = {"answer_bulk_question", "preview_cloud_privacy", "put_ai_debug_details", "put_client_preferences"}

{metalist-0.22.0 → metalist-0.23.0}/app/db/engine.py

@@ -60,10 +60,6 @@ class GuardedConnection:
         return self._connection
 
 
-def enable_read_guard() -> None:
-    _safe_session().enable_read_guard()
-
-
 @contextmanager
 def allow_reads(reason: str) -> Iterator[None]:
     with _safe_session().allow_reads(reason):