MetaList 0.23.0__tar.gz → 0.24.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.23.0
+Version: 0.24.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
@@ -53,6 +53,16 @@ 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.24.0
+
+- **Super tags.** A tag can carry values: `jogging:miles=3:duration=30`, `drug:dosage=10mg`, `run:start=10:30pm`. Search by them with `jogging:miles>2`, `jogging:miles?` (notes missing it), `date>=2024-01`, or `jogging:miles=MAX` / `=MIN` for the largest or smallest among the notes found. Values compare as numbers (a unit is a label: `dosage>5mg` compares only mg, `dosage>5` every unit), dates, times (`10:30pm` = `22:30`) or text. A search reads values through tag rules too: with `jogging => exercise`, `exercise:miles>2` finds your runs. The tag bar and the search box suggest the property names and units you already use, and `MAX`/`MIN` after `=`. A plain `jogging` search still finds `jogging:miles=3`; children inherit the tag, never its values.
+- Tag rules can test values: `jogging:miles>10 => long-run`, `task:due? => needs-date`. The tag a rule gives passes to the note's children; Edit Tag Relationships shows such a rule in the left column of the tag it gives, suggests names and units while you type one, and warns about a property no note has (a typo). Saving one re-tags only the notes it can concern.
+- The AI can propose super tags with values a note states (`jogging:miles=3` for "ran 3 miles"), reusing your property names and units; accepting one adds its values to the note's tag.
+- **Date range** (right-click menu, search box menu and command palette): show only notes created, or last updated, today, in the last 7 or 30 days, this year, or in a custom range. A chip in the search box names it; its `×`, a new search or leaving the tab ends it.
+- File names are searchable: a quoted search (`"congratulation"`) and find (Cmd/Ctrl+F) match the names of files a note holds, and the AI sees them.
+- ⌘+ / ⌘− with the pointer on a picture or diagram makes it bigger or smaller, viewing or editing.
+- Right-clicking the search box past what you typed offers View, Sort by and Date range.
+
 ## 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.

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

@@ -12,6 +12,16 @@ 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.24.0
+
+- **Super tags.** A tag can carry values: `jogging:miles=3:duration=30`, `drug:dosage=10mg`, `run:start=10:30pm`. Search by them with `jogging:miles>2`, `jogging:miles?` (notes missing it), `date>=2024-01`, or `jogging:miles=MAX` / `=MIN` for the largest or smallest among the notes found. Values compare as numbers (a unit is a label: `dosage>5mg` compares only mg, `dosage>5` every unit), dates, times (`10:30pm` = `22:30`) or text. A search reads values through tag rules too: with `jogging => exercise`, `exercise:miles>2` finds your runs. The tag bar and the search box suggest the property names and units you already use, and `MAX`/`MIN` after `=`. A plain `jogging` search still finds `jogging:miles=3`; children inherit the tag, never its values.
+- Tag rules can test values: `jogging:miles>10 => long-run`, `task:due? => needs-date`. The tag a rule gives passes to the note's children; Edit Tag Relationships shows such a rule in the left column of the tag it gives, suggests names and units while you type one, and warns about a property no note has (a typo). Saving one re-tags only the notes it can concern.
+- The AI can propose super tags with values a note states (`jogging:miles=3` for "ran 3 miles"), reusing your property names and units; accepting one adds its values to the note's tag.
+- **Date range** (right-click menu, search box menu and command palette): show only notes created, or last updated, today, in the last 7 or 30 days, this year, or in a custom range. A chip in the search box names it; its `×`, a new search or leaving the tab ends it.
+- File names are searchable: a quoted search (`"congratulation"`) and find (Cmd/Ctrl+F) match the names of files a note holds, and the AI sees them.
+- ⌘+ / ⌘− with the pointer on a picture or diagram makes it bigger or smaller, viewing or editing.
+- Right-clicking the search box past what you typed offers View, Sort by and Date range.
+
 ## 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.

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

@@ -124,6 +124,18 @@ class UpdateTabSortModeRequest(TypedDict):
     clientId: Identifier
     undoContext: UndoContext
 
+@with_config(ConfigDict(strict=True))
+class UpdateTabDateFilterRequest(TypedDict):
+    tabId: Identifier
+    field: Literal["created", "updated"]
+    # "none" shows every date again.
+    rangeKind: Literal["none", "today", "last-7-days", "last-30-days", "this-year", "custom"]
+    # A custom range's ends (YYYY-MM-DD); "" for an open end, and for every other range.
+    fromDate: Text
+    toDate: Text
+    clientId: Identifier
+    undoContext: UndoContext
+
 @with_config(ConfigDict(strict=True))
 class CreateNewTabRequest(TypedDict):
     copyFromTabId: Identifier

{metalist-0.23.0 → metalist-0.24.0}/app/api/routes/ai.py

@@ -498,6 +498,7 @@ def suggest_tags_for_note_with_ai(
     scope = resolve_view_scope_membership(
         search=payload.search,
         sort_mode=tab_state_store.get_sort_mode(tab_id=payload.tab_id),
+        date_filter=tab_state_store.get_date_filter(tab_id=payload.tab_id),
         is_untagged_view=payload.is_untagged_view,
     )
     if note_id not in scope.allowed_note_ids:
@@ -559,6 +560,7 @@ def _export_title_request(scope: ExportTitleScope, token: str) -> ExportTitleReq
     root_ids, allowed_note_ids = resolve_export_scope(
         search=search,
         sort_mode=tab_state_store.get_sort_mode(tab_id=scope.tab_id),
+        date_filter=tab_state_store.get_date_filter(tab_id=scope.tab_id),
         is_untagged_view=scope.is_untagged_view, root_note_id=note_id,
     )
     boundary = resolve_cloud_privacy_boundary(preferences=load_client_preferences(token=token), provider=scope.provider)
@@ -903,21 +905,26 @@ def stream_ai_chat(
     authoritative_sort_mode = tab_state_store.get_sort_mode(
         tab_id=payload.scope.scope_tab_id
     )
+    authoritative_date_filter = tab_state_store.get_date_filter(tab_id=payload.scope.scope_tab_id)
     active_search_query = authoritative_search_query
     active_sort_mode = authoritative_sort_mode
+    active_date_filter = authoritative_date_filter
     if payload.selected_note_id and payload.scope.active_tab_id != payload.scope.scope_tab_id:
         active_search_query = tab_state_store.get_search_query(tab_id=authoritative_active_tab_id)
         active_sort_mode = tab_state_store.get_sort_mode(tab_id=authoritative_active_tab_id)
+        active_date_filter = tab_state_store.get_date_filter(tab_id=authoritative_active_tab_id)
     frozen_scope = scoped_search_snapshot_factory.freeze(
         descriptor=payload.scope,
         authoritative_search_query=authoritative_search_query,
         authoritative_sort_mode=authoritative_sort_mode,
+        authoritative_date_filter=authoritative_date_filter,
         run_id=str(uuid4()),
         session_key=session_key,
         privacy_boundary=privacy_boundary,
         selected_note_id=payload.selected_note_id,
         authoritative_active_search_query=active_search_query,
         authoritative_active_sort_mode=active_sort_mode,
+        authoritative_active_date_filter=active_date_filter,
     )
     tagging_run = TaggingRun(token=token, snapshot=frozen_scope, privacy_boundary=privacy_boundary,
         preferences=preferences, sync_uuid=get_current_sync_uuid(),
@@ -1054,7 +1061,9 @@ def manage_bulk_proposals(payload: BulkManageRequest, token: Annotated[str, Depe
         raise HTTPException(status_code=HTTPStatus.CONFLICT, detail="Search context changed")
     async def execute():
         with bulk_operation_guard.acquire(token_service.get_session_key(token)):
-            note_ids = proposal_scope_ids(payload.scope)
+            note_ids = proposal_scope_ids(
+                payload.scope, date_filter=tab_state_store.get_date_filter(tab_id=payload.scope.scope_tab_id),
+            )
             if payload.target == "namespace":
                 note_ids = tuple(note_store.list_note_ids())
             changes, count, _ = prepare_proposal_changes(

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

@@ -13,6 +13,7 @@ from app.api.note_requests import (
     ViewDiffRequest,
     FindInListRequest,
     UpdateTabStateRequest,
+    UpdateTabDateFilterRequest,
     UpdateTabSortModeRequest,
     CreateNewTabRequest,
     DeleteTabRequest,
@@ -63,6 +64,14 @@ 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.root_date_filter import DATE_RANGE_NONE
+from app.services.tag_properties import PROPERTY_SUGGESTIONS_IN_SEARCH
+from app.services.tag_properties import PROPERTY_SUGGESTIONS_IN_TAG_BAR
+from app.services.tag_properties import PropertySuggestion
+from app.services.tag_properties import has_property_syntax
+from app.services.tag_properties import is_property_term
+from app.services.root_date_filter import RootDateFilter
+from app.services.root_date_filter import make_root_date_filter
 from app.services.snapshot import build_view_state
 from app.services.snapshot import find_in_view
 from app.services.snapshot import resolve_search_scope
@@ -262,6 +271,13 @@ def _resolve_tab_sort_mode(tab_id: object) -> str:
     return sort_mode
 
 
+def _resolve_tab_date_filter(tab_id: str) -> RootDateFilter | None:
+    """The tab's date range filter (None: every date), as its sort order is resolved."""
+    if not isinstance(tab_id, str) or tab_id == "":
+        raise TypeError("tabId must be a non-empty string")
+    return tab_state_store.get_date_filter(tab_id=tab_id)
+
+
 def _block_root_reorder_when_sorted(note_id: str, *, tab_id: object, new_parent_id: object) -> None:
     sort_mode = _resolve_tab_sort_mode(tab_id)
     if not is_root_reorder_locked(sort_mode):
@@ -367,6 +383,7 @@ def view_diff(payload: ViewDiffRequest):
         find_reveal_note_id=find_reveal_note_id,
         search=normalized_search,
         sort_mode=sort_mode,
+        date_filter=_resolve_tab_date_filter(tab_id),
         client_known_note_ids=client_known_note_ids,
         previous_root_ids=previous_root_ids,
         visible_top_root_id=visible_top_root_id,
@@ -474,6 +491,23 @@ def update_tab_sort_mode(payload: UpdateTabSortModeRequest) -> Dict[str, object]
     return response
 
 
+@router.post("/notes/tab-state/date-filter")
+@transactional_route
+def update_tab_date_filter(payload: UpdateTabDateFilterRequest) -> Dict[str, object]:
+    """Set or clear a tab's date range filter (root_date_filter.py). A range that is
+    not one (its start after its end, say) is answered as rejected input."""
+    date_filter: RootDateFilter | None = None
+    if payload["rangeKind"] != DATE_RANGE_NONE:
+        date_filter = make_root_date_filter(
+            field=payload["field"], range_kind=payload["rangeKind"],
+            from_date=payload["fromDate"], to_date=payload["toDate"],
+        )
+    response = tab_state_store.set_date_filter(tab_id=payload["tabId"], date_filter=date_filter)
+    if response["changed"] is True:
+        reset_undo_stack(payload["clientId"], payload["undoContext"])
+    return response
+
+
 @router.post("/notes/tab-state/new-tab")
 @transactional_route
 def create_new_tab(payload: CreateNewTabRequest) -> Dict[str, object]:
@@ -523,6 +557,15 @@ def search_suggestions(request: Request, payload: SearchSuggestionsRequest) -> D
         )
     window_days = tuple(raw_window_days)
     validate_tag_activity_windows(window_days)
+    # Typing a property term (exercise:mi, drug:dosage>5): its names or units.
+    typed_term = _typed_property_term(query)
+    if typed_term is not None:
+        return _property_suggestions_response(
+            search_index.suggest_property_completions(
+                typed=typed_term, place=PROPERTY_SUGGESTIONS_IN_SEARCH, limit=MAX_SEARCH_SUGGESTIONS,
+            ),
+            personalized=True,
+        )
     all_suggestions = search_index.suggest_all_tag_completions(query=query)
     suggestions = all_suggestions[:MAX_SEARCH_SUGGESTIONS]
     personalized_selections: list[TagActivityWindowSelection] = []
@@ -561,9 +604,33 @@ def search_suggestions(request: Request, payload: SearchSuggestionsRequest) -> D
             tag: list(search_suggestion_reasons(facts=facts, term=tag, recent_activity=recent_activity))
             for tag in suggestions
         },
+        "labels": {tag: tag for tag in suggestions},
     }
 
 
+def _typed_property_term(query: str) -> str | None:
+    """The property term being typed at the end of a search, without its - or +."""
+    if query == "" or query[-1].isspace():
+        return None
+    term = query.split()[-1].lstrip("+-")
+    if '"' in term or "'" in term or not is_property_term(term):
+        return None
+    return term
+
+
+def _property_suggestions_response(suggestions: list[PropertySuggestion], *, personalized: bool) -> Dict[str, object]:
+    """Property names or units as the suggestion lists take them: the full replacement,
+    the part the list shows (miles= for jogging:miles=) and why."""
+    response: Dict[str, object] = {
+        "suggestions": [suggestion.replacement for suggestion in suggestions],
+        "reasons": {suggestion.replacement: list(suggestion.reasons) for suggestion in suggestions},
+        "labels": {suggestion.replacement: suggestion.label for suggestion in suggestions},
+    }
+    if personalized:
+        response["personalizedSuggestions"] = []
+    return response
+
+
 @router.post("/notes/prioritize-tag-suggestions")
 @transactional_route
 def prioritize_tag_suggestions(payload: PrioritizeTagSuggestionsRequest) -> Dict[str, object]:
@@ -664,6 +731,7 @@ def find_in_list(payload: FindInListRequest) -> Dict[str, object]:
         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"]),
+        date_filter=_resolve_tab_date_filter(payload["tabId"]),
         is_untagged_view=payload["isUntaggedView"], from_root_index=payload["fromRootIndex"],
         direction=payload["direction"],
     )
@@ -737,6 +805,15 @@ def tag_suggestions(payload: TagSuggestionsRequest) -> Dict[str, object]:
 
     _require_note_present(note_id, context="notes.tag-suggestions")
 
+    # Typing after a tag's colon (jogging:mi, drug:dosage=10m): property names or units.
+    if has_property_syntax(prefix):
+        return _property_suggestions_response(
+            search_index.suggest_property_completions(
+                typed=prefix, place=PROPERTY_SUGGESTIONS_IN_TAG_BAR, limit=MAX_TAG_SUGGESTIONS,
+            ),
+            personalized=False,
+        )
+
     suggestions = suggest_tags_with_reasons_for_note(
         note_id=note_id,
         anchors=anchors,
@@ -749,6 +826,7 @@ def tag_suggestions(payload: TagSuggestionsRequest) -> Dict[str, object]:
     return {
         "suggestions": [suggestion.tag for suggestion in suggestions],
         "reasons": {suggestion.tag: list(suggestion.reasons) for suggestion in suggestions},
+        "labels": {suggestion.tag: suggestion.tag for suggestion in suggestions},
     }
 
 
@@ -797,6 +875,7 @@ def export_summary(request: Request) -> Dict[str, object]:
         normalized_search = None
     counts = exported_credential_counts(
         search=normalized_search, sort_mode=_resolve_tab_sort_mode(tab_id),
+        date_filter=_resolve_tab_date_filter(tab_id),
         is_untagged_view=is_untagged_view == "true", root_note_id=note_id,
     )
     return {
@@ -856,6 +935,7 @@ def export_notes_html(request: Request) -> Response:
     document = build_notes_export_document(
         search=normalized_search,
         sort_mode=_resolve_tab_sort_mode(tab_id),
+        date_filter=_resolve_tab_date_filter(tab_id),
         is_untagged_view=is_untagged_view == "true",
         theme=normalized_theme,
         token=token,
@@ -917,6 +997,7 @@ def backlinks(request: Request, note_id: str) -> Dict[str, object]:
             search=normalized_search,
             editing_note_id=None,
             sort_mode="normal",
+            date_filter=None,
             ordered_root_ids=None,
         )
         source_note_ids = search_scope.allowed_note_ids
@@ -1117,6 +1198,7 @@ def _robot_scope_note_ids(body: dict) -> frozenset[str]:
     return resolve_view_scope_membership(
         search=body["search"],
         sort_mode=_resolve_tab_sort_mode(body["tabId"]),
+        date_filter=_resolve_tab_date_filter(body["tabId"]),
         is_untagged_view=body["isUntaggedView"],
     ).allowed_note_ids
 

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

@@ -21,7 +21,8 @@ from app.services.tag_term_matching import list_significant_content_match_segmen
 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
+from app.services.tag_properties import PROPERTY_SUGGESTIONS_IN_RULE, is_property_term
+from app.services.tag_ontology import PropertyAtom, RegexAtom, TagAtom, TextAtom, parse_rules_text, rule_text_tests_values
 from app.services.ontology_rules_store import (
     build_direct_edge_rule_map,
     create_rule_line,
@@ -97,6 +98,10 @@ def _collect_candidate_note_ids_for_rules(rules: list) -> set[str]:
         tags: list[str] = []
         phrases: list[str] = []
         regexes: list[re.Pattern[str]] = []
+        # A rule testing super tag values changes notes' own tags: _refresh_note_tags
+        # rebuilds every note's, so it needs no candidates.
+        if any(isinstance(atom, PropertyAtom) for atom in rule.lhs):
+            continue
         for atom in rule.lhs:
             if isinstance(atom, TagAtom):
                 tags.append(atom.tag)
@@ -133,6 +138,32 @@ def _collect_candidate_note_ids_for_rules(rules: list) -> set[str]:
     return candidates
 
 
+def _rule_warnings(text: str) -> list[str]:
+    """What looks wrong in a saved rule: a super tag term no note can match, most likely
+    a typo (jogging:mile>10 where notes say miles)."""
+    warnings: list[str] = []
+    for rule in parse_rules_text(text=f"{text}\n", filename="ontology_rules:warnings"):
+        for atom in rule.lhs:
+            if not isinstance(atom, PropertyAtom):
+                continue
+            condition = atom.condition
+            if search_index.uses_property(tag=condition.tag, property_name=condition.name):
+                continue
+            warnings.append(f"No note has {condition.tag}:{condition.name} yet; check the spelling.")
+    return warnings
+
+
+def _refresh_note_tags(candidate_note_ids: set[str], *, rule_texts: list[str]) -> None:
+    """After a rule changed: the candidate notes' tags. A rule testing super tag values
+    refreshes the notes it can concern, with their children and the notes referencing
+    them, since the tags it gives pass to those (NoteStore.refresh_tags_for_value_rules)."""
+    if any(rule_text_tests_values(text) for text in rule_texts):
+        note_store.refresh_tags_for_value_rules(rule_texts=[text for text in rule_texts if rule_text_tests_values(text)])
+        if all(rule_text_tests_values(text) for text in rule_texts):
+            return
+    note_store.rebuild_search_index_tag_terms_for_notes(candidate_note_ids)
+
+
 def _collect_candidate_note_ids_for_texts(texts: list[str], *, filename: str) -> set[str]:
     candidates: set[str] = set()
     for text in texts:
@@ -181,10 +212,10 @@ def create_rule(request: Request, payload: RuleTextRequest) -> dict:
     token = _maybe_bearer_token(request)
     rule_id, normalized = create_rule_line(text=text, token=token)
     if note_store.loaded:
-        note_store.rebuild_search_index_tag_terms_for_notes(candidate_note_ids)
+        _refresh_note_tags(candidate_note_ids, rule_texts=[text])
         update_uuid = generate_new_uuid()
-        return {"id": rule_id, "text": normalized, "updateUUID": update_uuid}
-    return {"id": rule_id, "text": normalized}
+        return {"id": rule_id, "text": normalized, "updateUUID": update_uuid, "warnings": _rule_warnings(normalized)}
+    return {"id": rule_id, "text": normalized, "warnings": []}
 
 
 @router.put("/rules/{rule_id}")
@@ -210,18 +241,19 @@ def update_rule(request: Request, rule_id: int, payload: RuleTextRequest) -> dic
                 break
         if old_text is None:
             raise RuntimeError("Expected rule text for update")
+        rule_texts = [old_text, text]
         candidate_note_ids = _collect_candidate_note_ids_for_texts(
-            [old_text, text],
+            rule_texts,
             filename=f"ontology_rules:{rule_id}",
         )
 
     token = _maybe_bearer_token(request)
     updated_id, normalized = update_rule_line(rule_id=rule_id, text=text, token=token)
     if note_store.loaded:
-        note_store.rebuild_search_index_tag_terms_for_notes(candidate_note_ids)
+        _refresh_note_tags(candidate_note_ids, rule_texts=rule_texts)
         update_uuid = generate_new_uuid()
-        return {"id": updated_id, "text": normalized, "updateUUID": update_uuid}
-    return {"id": updated_id, "text": normalized}
+        return {"id": updated_id, "text": normalized, "updateUUID": update_uuid, "warnings": _rule_warnings(normalized)}
+    return {"id": updated_id, "text": normalized, "warnings": []}
 
 
 @router.delete("/rules/{rule_id}")
@@ -241,14 +273,15 @@ def delete_rule(rule_id: int) -> dict:
                 break
         if old_text is None:
             raise RuntimeError("Expected rule text for delete")
+        rule_texts = [old_text]
         candidate_note_ids = _collect_candidate_note_ids_for_texts(
-            [old_text],
+            rule_texts,
             filename=f"ontology_rules:{rule_id}",
         )
 
     delete_rule_line(rule_id=rule_id)
     if note_store.loaded:
-        note_store.rebuild_search_index_tag_terms_for_notes(candidate_note_ids)
+        _refresh_note_tags(candidate_note_ids, rule_texts=rule_texts)
         update_uuid = generate_new_uuid()
         return {"ok": True, "updateUUID": update_uuid}
     return {"ok": True}
@@ -306,6 +339,8 @@ def focus_view(tag: str) -> dict:
             return "text", f'"{escaped}"'
         if isinstance(atom, RegexAtom):
             return "regex", f"/{atom.pattern}/{atom.flags}"
+        if isinstance(atom, PropertyAtom):
+            return "value", atom.condition.format()
         raise TypeError(f"Unknown atom: {type(atom)}")
 
     def atom_payload(atom: object) -> dict:
@@ -316,6 +351,10 @@ def focus_view(tag: str) -> dict:
             return {"kind": kind, "text": display}
         if kind == "regex":
             return {"kind": kind, "regex": display}
+        if kind == "value":
+            # A super tag term: its tag is a chip like any tag, the rest is shown as written.
+            assert isinstance(atom, PropertyAtom)
+            return {"kind": kind, "value": display, "tag": atom.condition.tag}
         raise RuntimeError(f"Unexpected atom kind: {kind}")
 
     def format_atom_for_edit(atom: object) -> str:
@@ -327,6 +366,8 @@ def focus_view(tag: str) -> dict:
         if isinstance(atom, RegexAtom):
             escaped = atom.pattern.replace("\\", "\\\\").replace("/", "\\/")
             return f"/{escaped}/{atom.flags}"
+        if isinstance(atom, PropertyAtom):
+            return atom.condition.format()
         raise TypeError(f"Unknown atom: {type(atom)}")
 
     def record_equality_rule_ids(rules: list, rule_id: int) -> bool:
@@ -555,6 +596,18 @@ def list_tags(q: str, limit: int, focus: str, relation: str) -> dict:
     if (relation == "none") != (focus == ""):
         raise ValueError("A focus tag goes with a relation, and only with one")
 
+    # A super tag term in an incoming condition (jogging:mi, drug:dosage>5): its property
+    # names, units and values, as a rule reads them (docs/design/tag-properties.md).
+    if relation == "incoming" and is_property_term(q):
+        suggestions = search_index.suggest_property_completions(typed=q, place=PROPERTY_SUGGESTIONS_IN_RULE, limit=limit)
+        return {
+            "totalCount": len(suggestions),
+            "tags": [
+                {"tag": suggestion.replacement, "count": suggestion.note_count, "label": suggestion.label}
+                for suggestion in suggestions
+            ],
+        }
+
     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)}
@@ -568,12 +621,12 @@ def list_tags(q: str, limit: int, focus: str, relation: str) -> dict:
             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]]
+        payload = [{"tag": tag, "count": tag_counts[tag], "label": tag} for tag in ordered[:limit]]
         return {"totalCount": len(tag_counts), "tags": payload}
 
     if needle == "":
         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]}
+        return {"totalCount": len(tag_counts), "tags": [{"tag": tag, "count": tag_counts[tag], "label": tag} for tag in ordered]}
 
     matches: list[tuple[int, int, str]] = []
     for tag in tag_counts:
@@ -582,5 +635,5 @@ def list_tags(q: str, limit: int, focus: str, relation: str) -> dict:
             matches.append((rank, -tag_counts[tag], tag))
     # By rank, then most used, then name.
     matches.sort()
-    payload = [{"tag": tag, "count": tag_counts[tag]} for _rank, _negative_count, tag in matches[:limit]]
+    payload = [{"tag": tag, "count": tag_counts[tag], "label": tag} for _rank, _negative_count, tag in matches[:limit]]
     return {"totalCount": len(tag_counts), "tags": payload}

{metalist-0.23.0 → metalist-0.24.0}/app/services/agent/cloud_privacy.py

@@ -14,7 +14,9 @@ from app.services.search_index import search_index
 from app.services.tag_case import build_preferred_tag_case_map
 from app.services.search_query import ParsedSearchQuery, SearchClause
 from app.services.search_query import format_search_query, format_search_term, parse_search_query
+from app.services.search_index import extract_ordered_tags_for_agent
 from app.services.tag_ontology import is_valid_tag_token
+from app.services.tag_properties import PROPERTY_SEPARATOR, has_property_syntax, split_property_segments, tag_part_of_token
 from app.services.content_formatting import extract_note_text_for_agent
 
 
@@ -106,6 +108,37 @@ def visible_tag_counts(boundary: CloudPrivacyBoundary) -> tuple[dict[str, str],
     return display, counts
 
 
+# The AI is shown at most this many properties in use (visible_super_tag_examples).
+_MAX_SUPER_TAG_EXAMPLES = 40
+
+
+def visible_super_tag_examples(boundary: CloudPrivacyBoundary) -> tuple[str, ...]:
+    """One example of each property in use on notes the AI may see, most used first
+    (jogging:miles=3, drug:dosage=10mg), so super tags it proposes reuse their names and
+    units (docs/design/tag-properties.md)."""
+    note_ids = tuple(note_store.list_note_ids())
+    hidden = cloud_privacy_evaluator.hidden_note_ids(note_ids=note_ids, boundary=boundary)
+    counts: Counter[tuple[str, str]] = Counter()
+    examples: dict[tuple[str, str], str] = {}
+    for note_id in note_ids:
+        tags = note_store.get_note(note_id).tags
+        if note_id in hidden or PROPERTY_SEPARATOR not in tags:
+            continue
+        for token in extract_ordered_tags_for_agent(tags):
+            if not has_property_syntax(token):
+                continue
+            tag = tag_part_of_token(token).split("=", 1)[0]
+            for segment in split_property_segments(token[len(tag_part_of_token(token)) + 1:]):
+                name, has_value, value = segment.partition("=")
+                if not has_value or value == "":
+                    continue
+                key = (tag.casefold(), name.casefold())
+                counts[key] += 1
+                if key not in examples:
+                    examples[key] = f"{tag}{PROPERTY_SEPARATOR}{name}={value}"
+    return tuple(examples[key] for key, _count in counts.most_common(_MAX_SUPER_TAG_EXAMPLES))
+
+
 # What the AI is shown in place of a search term it may not see.
 PRIVATE_SEARCH_TERM = "[private]"
 
@@ -135,6 +168,7 @@ def _disclosable_clause_terms(
     """The clause's terms as the AI may be shown them, and whether any was withheld."""
     required_terms = [format_search_term(tag, is_phrase=False, is_excluded=False) for tag in sorted(clause.required_tags)]
     required_terms += [format_search_term(phrase, is_phrase=True, is_excluded=False) for phrase in clause.required_text]
+    required_terms += [condition.format() for condition in clause.required_properties]
     shown: list[str] = []
     withheld = False
     # Every required term picks out the same notes: the ones the clause finds.
@@ -148,7 +182,9 @@ def _disclosable_clause_terms(
     for tag in sorted(clause.forbidden_tags):
         removed = SearchClause(required_tags=clause.required_tags | {tag},
                                forbidden_tags=clause.forbidden_tags - {tag},
-                               required_text=clause.required_text, forbidden_text=clause.forbidden_text)
+                               required_text=clause.required_text, forbidden_text=clause.forbidden_text,
+                               required_properties=clause.required_properties,
+                               forbidden_properties=clause.forbidden_properties)
         if finds_visible_note(_clause_search(removed)):
             shown.append(format_search_term(tag, is_phrase=False, is_excluded=True))
         else:
@@ -156,11 +192,23 @@ def _disclosable_clause_terms(
     for index, phrase in enumerate(clause.forbidden_text):
         removed = SearchClause(required_tags=clause.required_tags, forbidden_tags=clause.forbidden_tags,
                                required_text=clause.required_text + (phrase,),
-                               forbidden_text=clause.forbidden_text[:index] + clause.forbidden_text[index + 1:])
+                               forbidden_text=clause.forbidden_text[:index] + clause.forbidden_text[index + 1:],
+                               required_properties=clause.required_properties,
+                               forbidden_properties=clause.forbidden_properties)
         if finds_visible_note(_clause_search(removed)):
             shown.append(format_search_term(phrase, is_phrase=True, is_excluded=True))
         else:
             excluded_withheld = True
+    for index, condition in enumerate(clause.forbidden_properties):
+        removed = SearchClause(required_tags=clause.required_tags, forbidden_tags=clause.forbidden_tags,
+                               required_text=clause.required_text, forbidden_text=clause.forbidden_text,
+                               required_properties=clause.required_properties + (condition,),
+                               forbidden_properties=clause.forbidden_properties[:index]
+                               + clause.forbidden_properties[index + 1:])
+        if finds_visible_note(_clause_search(removed)):
+            shown.append(f"-{condition.format()}")
+        else:
+            excluded_withheld = True
     if excluded_withheld:
         shown.append(f"-{PRIVATE_SEARCH_TERM}")
     return shown, withheld or excluded_withheld

{metalist-0.23.0 → metalist-0.24.0}/app/services/agent/note_tag_suggestions.py

@@ -26,7 +26,7 @@ from dataclasses import dataclass
 
 from app.services.agent.cloud_privacy import CloudPrivacyBoundary
 from app.services.agent.cloud_privacy import cloud_privacy_evaluator
-from app.services.agent.cloud_privacy import visible_tag_counts
+from app.services.agent.cloud_privacy import visible_super_tag_examples, visible_tag_counts
 from app.services.agent.inference import InferenceAdapter
 from app.services.agent.skill_settings import AgentSkill
 from app.services.agent.tagging import TagBatch
@@ -37,7 +37,8 @@ from app.services.agent.token_estimation import estimate_input_tokens
 from app.services.agent.web_settings import AgentWebSettings
 from app.services.content_formatting import extract_note_text_for_agent
 from app.services.note_store import store as note_store
-from app.services.search_index import extract_ordered_tags_for_search
+from app.services.search_index import extract_ordered_tags_for_agent, extract_ordered_tags_for_search
+from app.services.tag_properties import tag_part_of_token
 from app.services.search_index import search_index
 from app.services.tag_suggestions import suggest_tags_for_note
 from app.contracts import preserves, produces, requires
@@ -88,6 +89,8 @@ class NoteTagRequest:
     tag_skill: AgentSkill
     # The tags on notes the AI may see (cloud_privacy.visible_tag_counts).
     visible_vocabulary: dict[str, str]
+    # One example of each property in use there (cloud_privacy.visible_super_tag_examples).
+    super_tag_examples: tuple[str, ...]
 
 
 @dataclass(frozen=True, slots=True)
@@ -123,7 +126,7 @@ def _note_text(note_id: str) -> dict[str, object]:
     record = note_store.get_note(note_id)
     content, redacted = extract_note_text_for_agent(content_html=record.content, tags=record.tags)
     assert not redacted, "A note the AI may see is never password protected"
-    return {"content_text": content, "tags": list(extract_ordered_tags_for_search(record.tags))}
+    return {"content_text": content, "tags": list(extract_ordered_tags_for_agent(record.tags))}
 
 
 def _note_node(note_id: str) -> dict[str, object]:
@@ -212,6 +215,7 @@ def build_note_tag_request(
         ancestors_by_batch=tuple(context for _trees, context in groups),
         vocabulary=vocabulary, rules=rules, tag_skill=tag_skill,
         visible_vocabulary=visible_tag_counts(boundary)[0],
+        super_tag_examples=visible_super_tag_examples(boundary),
     ), "cloud_disclosable")
 
 
@@ -226,6 +230,7 @@ def request_messages(request: NoteTagRequest, index: int, prior_batch_new_tags:
         "accepted_vocabulary": [tag for tag, _count in request.vocabulary],
         "accepted_vocabulary_note_counts": [count for _tag, count in request.vocabulary],
         "prior_batch_new_tags": list(prior_batch_new_tags),
+        "super_tag_properties": list(request.super_tag_examples),
     }
     messages = tag_batch_messages(
         tag_skill=request.tag_skill, vocabulary_scope=_VOCABULARY_SCOPE, focus="both", user_payload=user_payload,
@@ -240,7 +245,8 @@ def keep_new_tags_up_to_limit(*, tags: tuple[str, ...], visible_vocabulary: dict
     kept = []
     new_count = 0
     for tag in tags:
-        if tag.casefold() not in visible_vocabulary:
+        # A super tag is new when its tag is (jogging:miles=3 on an existing jogging is not).
+        if tag_part_of_token(tag).casefold() not in visible_vocabulary:
             if new_count == MAX_NEW_TAGS:
                 continue
             new_count += 1