MetaList 0.19.0__tar.gz → 0.20.0__tar.gz

{metalist-0.19.0/metalist.egg-info → metalist-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.19.0
+Version: 0.20.0
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://github.com/evolvingstuff/metalist
 Project-URL: Repository, https://github.com/evolvingstuff/metalist
@@ -51,6 +51,17 @@ 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.20.0
+
+- **Suggest Tags with AI** for the note being edited: right-click the note, or its tag bar past the tags, and choose 🤖 Suggest Tags with AI (for a note with children: This Note, or This Note and Its Children). The proposals appear under the tag bar for `+`/`−`, tags not yet in use marked **new** and grouped on the right; adding them can be undone. It shows only when an AI is set up and may see the note.
+- The robot count (🤖 N) next to a note: click it to open every collapsed note on the way to its proposals and edit the highest one that has some; right-click it to Accept All or Reject All, one undo step.
+- **Print**: the note menu's Print ▸ Note / View, the background menu's Print View, or the palette's Print view, through the browser's print dialog (Save as PDF included). Always light, fully expanded, without arrows, using the page's full width with its own margins, so the browser prints no header or footer.
+- Export as HTML and Print open one dialog: a title with a smart default (the note's first line, or MetaList with the view's search), which heads the page unless the first note already says it and names an exported file; 🤖 Suggest with AI for the title, asked only when you press it, which never sees private notes, usernames, passwords or the search; and, when some would show, an Include Unredacted Passwords / Usernames checkbox (unchecked: each shows `••••••••`, whatever its length).
+- Exported HTML files show the view as it is shown (its search, sort order, Untagged view; notes a search leaves out are absent), start fully expanded with MetaList's collapse arrows working in the file, and copy usernames, included passwords and `@copyable` values on click. Collapsing no longer shifts the page sideways.
+- `@username` notes are private like `@password`: never sent to the AI. Username, password and email rows show just their icon, named on hover, and the value.
+- Text never runs out of its note: a word too long for the line (a token, a hash, a long URL) breaks at the note's edge, and code, `@json`, `@diff`, CSV and Markdown code blocks wrap. Images shrink to fit their note or embedded note, and `@size` scales them only up to that width.
+- The light theme's header bar is black again, with white icons and count, and the AI chat header now lines up with the search bar.
+
 ## Changes in 0.19.0
 
 - Paste formats: pasting a fenced code block that names its language tags the note `@markdown`, and `@markdown` now colours that code like `@code=<language>` (with its label). Code copied from VS Code is tagged `@code=<its language>`, and cells copied from Excel, Google Sheets or Numbers become CSV text tagged `@csv`.

{metalist-0.19.0 → metalist-0.20.0}/README.md

@@ -12,6 +12,17 @@ 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.20.0
+
+- **Suggest Tags with AI** for the note being edited: right-click the note, or its tag bar past the tags, and choose 🤖 Suggest Tags with AI (for a note with children: This Note, or This Note and Its Children). The proposals appear under the tag bar for `+`/`−`, tags not yet in use marked **new** and grouped on the right; adding them can be undone. It shows only when an AI is set up and may see the note.
+- The robot count (🤖 N) next to a note: click it to open every collapsed note on the way to its proposals and edit the highest one that has some; right-click it to Accept All or Reject All, one undo step.
+- **Print**: the note menu's Print ▸ Note / View, the background menu's Print View, or the palette's Print view, through the browser's print dialog (Save as PDF included). Always light, fully expanded, without arrows, using the page's full width with its own margins, so the browser prints no header or footer.
+- Export as HTML and Print open one dialog: a title with a smart default (the note's first line, or MetaList with the view's search), which heads the page unless the first note already says it and names an exported file; 🤖 Suggest with AI for the title, asked only when you press it, which never sees private notes, usernames, passwords or the search; and, when some would show, an Include Unredacted Passwords / Usernames checkbox (unchecked: each shows `••••••••`, whatever its length).
+- Exported HTML files show the view as it is shown (its search, sort order, Untagged view; notes a search leaves out are absent), start fully expanded with MetaList's collapse arrows working in the file, and copy usernames, included passwords and `@copyable` values on click. Collapsing no longer shifts the page sideways.
+- `@username` notes are private like `@password`: never sent to the AI. Username, password and email rows show just their icon, named on hover, and the value.
+- Text never runs out of its note: a word too long for the line (a token, a hash, a long URL) breaks at the note's edge, and code, `@json`, `@diff`, CSV and Markdown code blocks wrap. Images shrink to fit their note or embedded note, and `@size` scales them only up to that width.
+- The light theme's header bar is black again, with white icons and count, and the AI chat header now lines up with the search bar.
+
 ## Changes in 0.19.0
 
 - Paste formats: pasting a fenced code block that names its language tags the note `@markdown`, and `@markdown` now colours that code like `@code=<language>` (with its label). Code copied from VS Code is tagged `@code=<its language>`, and cells copied from Excel, Google Sheets or Numbers become CSV text tagged `@csv`.

{metalist-0.19.0 → metalist-0.20.0}/app/api/note_requests.py

@@ -203,6 +203,36 @@ class AcceptTagProposalRequest(TypedDict):
     undoContext: UndoContext
     viewport: Viewport
 
+@with_config(ConfigDict(strict=True))
+class AddTagProposalsRequest(TypedDict):
+    # note id -> the AI's tags for it: the edited note and maybe notes below it.
+    proposals: Annotated[dict[Identifier, Annotated[list[Identifier], Field(min_length=1, max_length=12)]],
+                         Field(min_length=1, max_length=20_000)]
+    clientId: Identifier
+    undoContext: UndoContext
+    viewport: Viewport
+
+# The view a robot count (🤖 N) was shown in: its tab, search ('' for none) and kind.
+@with_config(ConfigDict(strict=True))
+class OpenToTagProposalsRequest(TypedDict):
+    search: Text
+    tabId: Identifier
+    isUntaggedView: bool
+    clientId: Identifier
+    undoContext: UndoContext
+    viewport: Viewport
+
+@with_config(ConfigDict(strict=True))
+class ResolveRobotProposalsRequest(TypedDict):
+    action: Literal["accept", "reject"]
+    includesHiddenChildren: bool
+    search: Text
+    tabId: Identifier
+    isUntaggedView: bool
+    clientId: Identifier
+    undoContext: UndoContext
+    viewport: Viewport
+
 @with_config(ConfigDict(strict=True))
 class RejectTagProposalRequest(TypedDict):
     proposal: Identifier

{metalist-0.19.0 → metalist-0.20.0}/app/api/routes/ai.py

@@ -18,6 +18,10 @@ from app.api.transactions import transactional_route
 from app.models.utils import note_data_to_html
 from app.models.utils import render_note_data_read_only
 from app.services.ai_chat_stream import ChatTurnStream
+from app.services.ai_setup import AiConnection
+from app.services.ai_setup import AiNotSetUp
+from app.services.ai_setup import AiProvider
+from app.services.ai_setup import connect_to_ai
 from app.services.ai_chat import ai_chat_store
 from app.services.ai_chat_rendering import find_note_citation_ids
 from app.services.ai_chat_rendering import find_web_citation_ids
@@ -27,9 +31,7 @@ from app.services.agent.cloud_privacy import cloud_privacy_evaluator
 from app.services.agent.cloud_privacy import resolve_cloud_privacy_boundary
 from app.services.agent.inference import InferenceAdapter
 from app.services.agent.model_policy import SingleModelPolicy
-from app.services.agent.openai_inference import OPENAI_API_BASE_URL
 from app.services.agent.openai_inference import OPENAI_MODELS
-from app.services.agent.openai_inference import OpenAIInferenceAdapter
 from app.services.agent.openai_inference import validate_openai_model
 from app.services.agent.openai_cost_tracking import OpenAICostSnapshot
 from app.services.agent.openai_cost_tracking import openai_cost_tracker
@@ -64,6 +66,19 @@ from app.usecases.bulk_tag_proposals import apply_bulk_proposals, prepare_propos
 from app.services.bulk_operation import bulk_operation_guard
 from app.services.tab_state import tab_state_store
 from app.services.tokens import token_service
+from app.services.agent.inference import InferenceProviderError
+from app.services.agent.note_tag_suggestions import build_note_tag_request
+from app.services.agent.export_title_suggestions import MAX_PREVIOUS_TITLES
+from app.services.agent.export_title_suggestions import ExportTitleRequest
+from app.services.agent.export_title_suggestions import build_export_title_request
+from app.services.agent.export_title_suggestions import suggest_export_title
+from app.services.agent.note_tag_suggestions import NoteTagRequest
+from app.services.agent.note_tag_suggestions import suggest_note_tags
+from app.services.snapshot import resolve_view_scope_membership
+from app.services.html_export import resolve_export_scope
+from app.services.ai_setup import describe_ai_setup
+from app.services.input_errors import InputRejected
+from app.utils.text_utils import strip_html
 
 
 router = APIRouter(prefix="/ai", tags=["ai"])
@@ -71,6 +86,15 @@ router = APIRouter(prefix="/ai", tags=["ai"])
 agent_context_builder = AgentContextBuilder()
 
 
+def _require_ai_connection(*, provider: AiProvider, token: str, session_key: str) -> AiConnection:
+    # lint: allow-PY001 rationale="the user removed or never added the AI's key: an expected 409, not a defect"
+    try:
+        return connect_to_ai(provider=provider, token=token, session_key=session_key)
+    # lint: allow-PY001 rationale="the user removed or never added the AI's key: an expected 409, not a defect"
+    except AiNotSetUp as exc:
+        raise HTTPException(status_code=409, detail="The AI is not set up: add its API key in AI settings") from exc
+
+
 def _agent_runtime(*, inference: InferenceAdapter) -> AgentRuntime:
     return AgentRuntime(
         context_builder=agent_context_builder,
@@ -163,6 +187,76 @@ class AiChatRequest(BaseModel):
         return self
 
 
+class NoteTagSuggestionAvailabilityRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    provider: AiProvider
+    # The note as it is being edited, unsaved changes included.
+    tags: str = Field(..., max_length=1024 * 1024)
+    content_html: str = Field(..., max_length=16 * 1024 * 1024)
+
+
+class NoteTagSuggestionAvailabilityResponse(BaseModel):
+    is_available: bool
+
+
+class NoteTagSuggestionRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    provider: AiProvider
+    model: str
+    thinking_level: Literal["off", "low", "medium", "high"]
+    # The note alone, or it and the notes below it the view shows.
+    include_children: bool
+    # The view the note is in ('' for no search).
+    search: str = Field(..., max_length=1024 * 1024)
+    tab_id: str = Field(..., min_length=1, max_length=256)
+    is_untagged_view: bool
+
+    @model_validator(mode="after")
+    def validate_model_for_provider(self) -> Self:
+        assert self.provider == "openai"
+        validate_openai_model(self.model)
+        return self
+
+
+class ExportTitleScope(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    provider: AiProvider
+    # The view exported or printed, or the one its note is in ('' for no search).
+    search: str = Field(..., max_length=1024 * 1024)
+    tab_id: str = Field(..., min_length=1, max_length=256)
+    is_untagged_view: bool
+    # A note with its children ("note"), or the view as it is shown ("view", note_id '').
+    exported: Literal["note", "view"]
+    note_id: str = Field(..., max_length=256)
+
+    @model_validator(mode="after")
+    def validate_exported_note(self) -> Self:
+        if (self.exported == "note") != (self.note_id != ""):
+            raise ValueError("A note's export names the note; the view's export names none")
+        return self
+
+
+class ExportTitleAvailabilityResponse(BaseModel):
+    # "unavailable": no AI is set up (no button); then as ExportTitleAvailability.
+    availability: Literal["unavailable", "nothing", "private", "partial", "ready"]
+
+
+class ExportTitleSuggestionRequest(ExportTitleScope):
+    model: str
+    thinking_level: Literal["off", "low", "medium", "high"]
+    # Titles the AI gave in this dialog: it gives another.
+    previous_titles: list[str] = Field(..., max_length=MAX_PREVIOUS_TITLES)
+
+    @model_validator(mode="after")
+    def validate_model_for_provider(self) -> Self:
+        assert self.provider == "openai"
+        validate_openai_model(self.model)
+        return self
+
+
 class AiChatActivity(BaseModel):
     sequence: int = Field(..., ge=1)
     action: str
@@ -330,6 +424,178 @@ def delete_openai_credential(
     )
 
 
+@router.post(
+    "/notes/{note_id}/tag-suggestions/availability",
+    response_model=NoteTagSuggestionAvailabilityResponse,
+)
+@transactional_route
+def note_tag_suggestion_availability(
+    note_id: str,
+    payload: NoteTagSuggestionAvailabilityRequest,
+    response: Response,
+    token: Annotated[str, Depends(require_request_auth_token)],
+) -> NoteTagSuggestionAvailabilityResponse:
+    """Whether "Suggest Tags with AI" applies: an AI is set up and may see the note as edited."""
+    response.headers["Cache-Control"] = "no-store"
+    if not note_store.has_note(note_id):
+        raise HTTPException(status_code=404, detail=f"Note not found: {note_id}")
+    session_key = token_service.get_session_key(token)
+    if not describe_ai_setup(token=token, session_key=session_key).is_ready_for(payload.provider):
+        return NoteTagSuggestionAvailabilityResponse(is_available=False)
+    boundary = resolve_cloud_privacy_boundary(
+        preferences=load_client_preferences(token=token),
+        provider=payload.provider,
+    )
+    draft_effective_tags = note_store.draft_effective_tag_terms(
+        note_id=note_id, tags=payload.tags, plaintext=strip_html(payload.content_html),
+    )
+    reason = cloud_privacy_evaluator.draft_exclusion_reason(
+        note_id=note_id, draft_effective_tags=draft_effective_tags,
+        draft_content_html=payload.content_html, boundary=boundary,
+    )
+    return NoteTagSuggestionAvailabilityResponse(is_available=reason == "")
+
+
+@router.post("/notes/{note_id}/tag-suggestions")
+@transactional_route
+def suggest_tags_for_note_with_ai(
+    note_id: str,
+    payload: NoteTagSuggestionRequest,
+    token: Annotated[str, Depends(require_request_auth_token)],
+) -> StreamingResponse:
+    """Ask the AI for the saved note's tags (and its children's): streams {"type": "progress"}
+    lines, then one {"type": "proposals"} or {"type": "failed"} line.
+
+    Nothing is written: the client adds what it gets back as proposals
+    (POST /notes/{id}/tag-proposals/add), one undo step.
+    """
+    if not note_store.has_note(note_id):
+        raise HTTPException(status_code=404, detail=f"Note not found: {note_id}")
+    session_key = token_service.get_session_key(token)
+    connection = _require_ai_connection(provider=payload.provider, token=token, session_key=session_key)
+    preferences = load_client_preferences(token=token)
+    boundary = resolve_cloud_privacy_boundary(preferences=preferences, provider=payload.provider)
+    if cloud_privacy_evaluator.exclusion_reason(note_id=note_id, boundary=boundary) != "":
+        raise InputRejected(
+            "Your AI privacy settings hide this note from the AI, so it can't suggest tags for it"
+        )
+    scope = resolve_view_scope_membership(
+        search=payload.search,
+        sort_mode=tab_state_store.get_sort_mode(tab_id=payload.tab_id),
+        is_untagged_view=payload.is_untagged_view,
+    )
+    if note_id not in scope.allowed_note_ids:
+        raise HTTPException(status_code=409, detail="The note is not in this view any more")
+    request = build_note_tag_request(
+        note_id=note_id, include_children=payload.include_children, boundary=boundary,
+        tag_skill=DEFAULT_AGENT_SKILLS.for_action("tag_proposals"), scope_note_ids=scope.allowed_note_ids,
+        batch_tokens=resolve_tagging_batch_tokens(preferences, payload.provider),
+    )
+    events = _note_tag_suggestion_events(
+        request=request, connection=connection, payload=payload,
+        web_settings=resolve_agent_web_settings(preferences=preferences), session_key=session_key,
+    )
+    return StreamingResponse(
+        events,
+        media_type="application/x-ndjson",
+        headers={"X-Accel-Buffering": "no", "Cache-Control": "no-store", "Content-Encoding": "identity"},
+    )
+
+
+async def _note_tag_suggestion_events(
+    *, request: NoteTagRequest, connection: AiConnection, payload: NoteTagSuggestionRequest,
+    web_settings: AgentWebSettings, session_key: str,
+) -> AsyncIterator[str]:
+    events = suggest_note_tags(
+        request=request, inference=connection.inference, base_url=connection.base_url,
+        model=payload.model, thinking_level=payload.thinking_level,
+        web_settings=web_settings, session_key=session_key,
+    )
+    # lint: allow-PY001 rationale="the AI provider failed or kept answering unusably: the client shows why"
+    try:
+        async for event in events:
+            yield json.dumps(event) + "\n"
+    # lint: allow-PY001 rationale="the AI provider failed or kept answering unusably: the client shows why"
+    except InferenceProviderError as exc:
+        yield json.dumps({"type": "failed", "message": str(exc)}) + "\n"
+    finally:
+        await events.aclose()
+
+
+def _export_title_request(scope: ExportTitleScope, token: str) -> ExportTitleRequest:
+    """What the AI may read of the export or print: the notes the AI privacy settings let it see."""
+    note_id = None
+    if scope.exported == "note":
+        note_id = scope.note_id
+        if not note_store.has_note(note_id):
+            raise HTTPException(status_code=404, detail=f"Note not found: {note_id}")
+    search = None
+    if scope.search != "":
+        search = scope.search
+    root_ids, allowed_note_ids = resolve_export_scope(
+        search=search,
+        sort_mode=tab_state_store.get_sort_mode(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)
+    return build_export_title_request(root_ids=root_ids, allowed_note_ids=allowed_note_ids, boundary=boundary)
+
+
+@router.post("/export-title/availability", response_model=ExportTitleAvailabilityResponse)
+@transactional_route
+def export_title_availability(
+    payload: ExportTitleScope,
+    response: Response,
+    token: Annotated[str, Depends(require_request_auth_token)],
+) -> ExportTitleAvailabilityResponse:
+    """Whether the Export and Print dialog's "Suggest with AI" can ask, and what it says about private notes."""
+    response.headers["Cache-Control"] = "no-store"
+    session_key = token_service.get_session_key(token)
+    if not describe_ai_setup(token=token, session_key=session_key).is_ready_for(payload.provider):
+        return ExportTitleAvailabilityResponse(availability="unavailable")
+    return ExportTitleAvailabilityResponse(availability=_export_title_request(payload, token).availability)
+
+
+@router.post("/export-title")
+@transactional_route
+def suggest_export_title_with_ai(
+    payload: ExportTitleSuggestionRequest,
+    token: Annotated[str, Depends(require_request_auth_token)],
+) -> StreamingResponse:
+    """Ask the AI for an export's or print's title: one {"type": "title"} or {"type": "failed"} line.
+    Streamed, so Stop (the client going away) ends the request."""
+    session_key = token_service.get_session_key(token)
+    connection = _require_ai_connection(provider=payload.provider, token=token, session_key=session_key)
+    request = _export_title_request(payload, token)
+    if not request.notes:
+        raise InputRejected("These notes are private, so the AI can't suggest a title")
+    web_mode = resolve_agent_web_settings(preferences=load_client_preferences(token=token)).mode
+    return StreamingResponse(
+        _export_title_events(
+            request=request, payload=payload, connection=connection, web_mode=web_mode, session_key=session_key,
+        ),
+        media_type="application/x-ndjson",
+        headers={"X-Accel-Buffering": "no", "Cache-Control": "no-store", "Content-Encoding": "identity"},
+    )
+
+
+async def _export_title_events(
+    *, request: ExportTitleRequest, payload: ExportTitleSuggestionRequest, connection: AiConnection,
+    web_mode: str, session_key: str,
+) -> AsyncIterator[str]:
+    # lint: allow-PY001 rationale="the AI provider failed or answered without a title: the dialog shows why"
+    try:
+        title = await suggest_export_title(
+            request=request, previous_titles=tuple(payload.previous_titles), inference=connection.inference,
+            base_url=connection.base_url, model=payload.model, thinking_level=payload.thinking_level,
+            web_mode=web_mode, session_key=session_key,
+        )
+        yield json.dumps({"type": "title", "title": title}) + "\n"
+    # lint: allow-PY001 rationale="the AI provider failed or answered without a title: the dialog shows why"
+    except InferenceProviderError as exc:
+        yield json.dumps({"type": "failed", "message": str(exc)}) + "\n"
+
+
 def _openai_cost_response(snapshot: OpenAICostSnapshot) -> OpenAICostResponse:
     return OpenAICostResponse(
         estimated_cost_usd=float(snapshot.estimated_cost_usd),
@@ -576,19 +842,7 @@ def stream_ai_chat(
     token: Annotated[str, Depends(require_request_auth_token)],
 ) -> StreamingResponse:
     session_key = token_service.get_session_key(token)
-    credential_status = openai_credential_store.status(
-        token=token,
-        session_key=session_key,
-    )
-    if not credential_status.configured:
-        raise HTTPException(
-            status_code=409,
-            detail="OpenAI API key is not configured",
-        )
-    openai_api_key = openai_credential_store.resolve(
-        token=token,
-        session_key=session_key,
-    )
+    connection = _require_ai_connection(provider=payload.provider, token=token, session_key=session_key)
     preferences = load_client_preferences(token=token)
     prompts = DEFAULT_AGENT_PROMPTS
     skills = DEFAULT_AGENT_SKILLS
@@ -655,7 +909,7 @@ def stream_ai_chat(
     turn_stream = ChatTurnStream(store=ai_chat_store, notes=note_store,
                                  web_evidence_store=web_evidence_store, session_key=session_key,
                                  turn_id=turn_id, initial_input_tokens=initial_approx_input_tokens)
-    events = _stream_runtime_events(payload=payload, openai_api_key=openai_api_key,
+    events = _stream_runtime_events(payload=payload, connection=connection,
         session_key=session_key, provider_messages=provider_messages, prompts=prompts, skills=skills,
         retrieval_settings=retrieval_settings, frozen_scope=frozen_scope, tagging_run=tagging_run,
         web_settings=web_settings, earlier_actions=earlier_actions,
@@ -673,16 +927,16 @@ def stream_ai_chat(
 
 
 async def _stream_runtime_events(
-    *, payload: AiChatRequest, openai_api_key: str, session_key: str,
+    *, payload: AiChatRequest, connection: AiConnection, session_key: str,
     provider_messages: list[dict[str, str]], prompts: AgentPromptSet, skills: AgentSkillSet,
     retrieval_settings: AgentRetrievalSettings, frozen_scope: ScopedSearchSnapshot,
     tagging_run: TaggingRun, initial_input_tokens: int, web_settings: AgentWebSettings,
     earlier_actions: list[dict[str, object]],
 ) -> AsyncIterator[dict[str, object]]:
-    action, start_label = 'provider_runtime', 'Connecting to OpenAI API'
-    ready_label = 'OpenAI API ready · 1,050,000-token context'
-    base_url = OPENAI_API_BASE_URL
-    runtime = _agent_runtime(inference=OpenAIInferenceAdapter(api_key=openai_api_key, cost_tracker=openai_cost_tracker))
+    action, start_label = 'provider_runtime', f'Connecting to {connection.label} API'
+    ready_label = connection.ready_label
+    base_url = connection.base_url
+    runtime = _agent_runtime(inference=connection.inference)
     yield dict(type='action_status', action=action, status='started', label=start_label,
                approx_input_tokens=initial_input_tokens, output_tokens_received=0, duration_ms=0.0)
     yield dict(type='action_status', action=action, status='completed', label=ready_label,

{metalist-0.19.0 → metalist-0.20.0}/app/api/routes/notes.py

@@ -31,7 +31,10 @@ from app.api.note_requests import (
     SaveNoteRequest,
     AddSelectedTextTagRequest,
     AcceptTagProposalRequest,
+    AddTagProposalsRequest,
+    OpenToTagProposalsRequest,
     RejectTagProposalRequest,
+    ResolveRobotProposalsRequest,
     SplitNoteRequest,
     ToggleTodoDoneRequest,
     UnformatNoteContentRequest,
@@ -60,6 +63,7 @@ from app.api.transactions import transactional_route
 from app.services.sync import touch_client
 from app.services.snapshot import build_view_state
 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
 from app.services.exception_capture import CapturedExceptionContext
 from app.usecases.create_note import CmdCreateNote
@@ -78,7 +82,10 @@ from app.services.link_title_retry import (
 from app.usecases.add_selected_text_tag import CmdAddSelectedTextTag
 from app.usecases.tag_proposals import (
     CmdAcceptTagProposal,
+    CmdAddTagProposals,
+    CmdOpenToTagProposals,
     CmdRejectTagProposal,
+    CmdResolveRobotProposals,
 )
 from app.usecases.delete_subtree import CmdDeleteSubtree
 from app.usecases.move import CmdMove
@@ -132,7 +139,10 @@ from app.services.search_history import (
 from app.services.root_sorting import is_root_reorder_locked
 from app.services.root_sorting import normalize_sort_mode
 from app.services.search_query import parse_search_query
+from app.services.html_export import EXPORT_PURPOSES
 from app.services.html_export import build_notes_export_document
+from app.services.html_export import default_export_title
+from app.services.html_export import exported_credential_counts
 from app.services.html_export import build_notes_export_filename
 from app.services.note_fullscreen import build_note_fullscreen_markup
 from app.services.link_titles import link_title_store
@@ -682,6 +692,35 @@ def search_tag_details(request: Request, payload: SearchTagDetailsRequest) -> Di
     return {"lines": list(lines)}
 
 
+@router.get("/notes/export-summary")
+def export_summary(request: Request) -> Dict[str, object]:
+    """What an export or print of a note (with its children) or of the view holds,
+    for its dialog: the title it starts with, and how many passwords and usernames it shows."""
+    _require_bearer_token(request)
+    search_query = request.query_params.get("search_query")
+    tab_id = request.query_params.get("tab_id")
+    is_untagged_view = request.query_params.get("is_untagged_view")
+    if search_query is None or tab_id is None or tab_id == "" or is_untagged_view not in {"true", "false"}:
+        raise HTTPException(status_code=400, detail="search_query, tab_id and is_untagged_view are required")
+    note_id = request.query_params.get("note_id")
+    if note_id is not None:
+        _require_note_present(note_id, context="notes.export-summary")
+    normalized_search = search_query
+    if normalized_search == "":
+        normalized_search = None
+    counts = exported_credential_counts(
+        search=normalized_search, sort_mode=_resolve_tab_sort_mode(tab_id),
+        is_untagged_view=is_untagged_view == "true", root_note_id=note_id,
+    )
+    return {
+        "title": default_export_title(
+            search=search_query, is_untagged_view=is_untagged_view == "true", root_note_id=note_id,
+        ),
+        "password_count": counts.passwords,
+        "username_count": counts.usernames,
+    }
+
+
 @router.get("/notes/export-html")
 def export_notes_html(request: Request) -> Response:
     token = _require_bearer_token(request)
@@ -709,14 +748,40 @@ def export_notes_html(request: Request) -> Response:
     normalized_theme = theme.strip().lower()
     if normalized_theme not in {"dark", "light"}:
         raise HTTPException(status_code=400, detail="theme must be 'light' or 'dark'")
+    # The view as the tab shows it: its sort order and kind (All or Untagged notes).
+    tab_id = request.query_params.get("tab_id")
+    if tab_id is None or tab_id == "":
+        raise HTTPException(status_code=400, detail="tab_id query parameter is required")
+    is_untagged_view = request.query_params.get("is_untagged_view")
+    if is_untagged_view not in {"true", "false"}:
+        raise HTTPException(status_code=400, detail="is_untagged_view query parameter must be 'true' or 'false'")
+
+    # Both carry the user's title; a download collapses and expands, a print is always light.
+    purpose = request.query_params.get("purpose")
+    if purpose not in EXPORT_PURPOSES:
+        raise HTTPException(status_code=400, detail="purpose query parameter must be 'download' or 'print'")
+    title = request.query_params.get("title")
+    if title is None:
+        raise HTTPException(status_code=400, detail="title query parameter is required")
+    if purpose == "print":
+        normalized_theme = "light"
+    # Passwords and usernames show only when the user chose to include them in this export.
+    include_credentials = request.query_params.get("include_credentials")
+    if include_credentials not in {"true", "false"}:
+        raise HTTPException(status_code=400, detail="include_credentials query parameter must be 'true' or 'false'")
 
     document = build_notes_export_document(
         search=normalized_search,
+        sort_mode=_resolve_tab_sort_mode(tab_id),
+        is_untagged_view=is_untagged_view == "true",
         theme=normalized_theme,
         token=token,
         root_note_id=note_id,
+        purpose=purpose,
+        title=title,
+        include_credentials=include_credentials == "true",
     )
-    filename = build_notes_export_filename()
+    filename = build_notes_export_filename(title)
     quoted_filename = urllib.parse.quote(filename)
     return Response(
         content=document,
@@ -967,6 +1032,67 @@ def accept_tag_proposal(request: Request, note_id: str, body: AcceptTagProposalR
     )
 
 
+@router.post("/notes/{note_id}/tag-proposals/add")
+@transactional_route
+def add_tag_proposals(request: Request, note_id: str, body: AddTagProposalsRequest):
+    token = _require_bearer_token(request)
+    viewport = _require_viewport(body)
+    _require_note_present(note_id, context="notes.tag-proposals.add")
+    return _execute_tag_proposal_mutation(
+        command=CmdAddTagProposals(
+            note_id=note_id,
+            proposals={target_id: tuple(tags) for target_id, tags in body["proposals"].items()},
+            token=token,
+            client_id=body["clientId"],
+            undo_context=body["undoContext"],
+            viewport=viewport,
+        )
+    )
+
+
+def _robot_scope_note_ids(body: dict) -> frozenset[str]:
+    """The notes the view showing a robot count lets it count (as /notes/view resolves them)."""
+    return resolve_view_scope_membership(
+        search=body["search"],
+        sort_mode=_resolve_tab_sort_mode(body["tabId"]),
+        is_untagged_view=body["isUntaggedView"],
+    ).allowed_note_ids
+
+
+@router.post("/notes/{note_id}/tag-proposals/open")
+@transactional_route
+def open_to_tag_proposals(note_id: str, body: OpenToTagProposalsRequest):
+    viewport = _require_viewport(body)
+    _require_note_present(note_id, context="notes.tag-proposals.open")
+    return CmdOpenToTagProposals(
+        note_id=note_id,
+        scope_note_ids=_robot_scope_note_ids(body),
+        client_id=body["clientId"],
+        undo_context=body["undoContext"],
+        viewport=viewport,
+    ).execute()
+
+
+@router.post("/notes/{note_id}/tag-proposals/resolve-all")
+@transactional_route
+def resolve_robot_tag_proposals(request: Request, note_id: str, body: ResolveRobotProposalsRequest):
+    token = _require_bearer_token(request)
+    viewport = _require_viewport(body)
+    _require_note_present(note_id, context="notes.tag-proposals.resolve-all")
+    return _execute_tag_proposal_mutation(
+        command=CmdResolveRobotProposals(
+            note_id=note_id,
+            action=body["action"],
+            includes_hidden_children=body["includesHiddenChildren"],
+            scope_note_ids=_robot_scope_note_ids(body),
+            token=token,
+            client_id=body["clientId"],
+            undo_context=body["undoContext"],
+            viewport=viewport,
+        )
+    )
+
+
 @router.post("/notes/{note_id}/tag-proposals/reject")
 @transactional_route
 def reject_tag_proposal(request: Request, note_id: str, body: RejectTagProposalRequest):

{metalist-0.19.0 → metalist-0.20.0}/app/exception_boundaries.py

@@ -171,6 +171,7 @@ CAPTURE_BOUNDARIES = {
     # Handle expected external I/O, provider, image or LaTeX parsing failure.
     'convert-from-legacy.py:_legacy_rule_is_currently_valid:parse_capture': ('OntologyParseError',),
     # Handle expected external I/O, provider, image or LaTeX parsing failure.
+    'main.py:_bind_https_proxy_server:bind_capture': ('OSError',),
     'main.py:_is_process_running:kill_capture': ('ProcessLookupError', 'PermissionError'),
     # Handle expected external I/O, provider, image or LaTeX parsing failure.
     'main.py:_send_signal_if_running:signal_capture': ('ProcessLookupError',),

{metalist-0.19.0 → metalist-0.20.0}/app/presentation/render/note_renderer.py

@@ -50,7 +50,7 @@ def _format_note_content_standard(*, content_html: str, tags: str) -> str:
     return format_note_content_for_view(
         content_html=content_html,
         tags=tags,
-        redact_passwords=False,
+        redact_credentials=False,
     )