basic-memory 0.23.2.dev3__py3-none-any.whl → 0.23.3.dev2__py3-none-any.whl

basic_memory/__init__.py

@@ -1,7 +1,7 @@
 """basic-memory - Local-first knowledge management combining Zettelkasten with knowledge graphs"""
 
 # Package version - updated by release automation
-__version__ = "0.23.1"
+__version__ = "0.23.2"
 
 # API version for FastAPI - independent of package version
 __api_version__ = "v2"

basic_memory/alembic/env.py

@@ -2,34 +2,24 @@
 
 import asyncio
 import os
-import sys
 from contextlib import suppress
 from logging.config import fileConfig
 
-from loguru import logger
 from sqlalchemy import engine_from_config, pool
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from alembic import context
 
 from basic_memory.config import ConfigManager
-from basic_memory.migration_loop import running_on_uvloop
 
-# Allow nested event loops (needed for pytest-asyncio and other async contexts).
-# nest_asyncio cannot patch a uvloop loop or Python 3.14+; in those cases we skip
-# it and rely on the thread-based fallback in run_migrations_online() instead
-# (see basic_memory.migration_loop for why uvloop must be detected up front).
-if sys.version_info < (3, 14) and not running_on_uvloop():
-    try:
-        import nest_asyncio
-
-        nest_asyncio.apply()
-    except (ImportError, ValueError) as exc:
-        # Trigger: nest_asyncio is absent (ImportError) or refuses to patch the
-        # running loop (ValueError).
-        # Outcome: log at DEBUG (observable, not noisy) and fall through to the
-        # thread-based migration fallback.
-        logger.debug(f"nest_asyncio not applied ({exc!r}); using thread-based migration fallback")
+# Constraint: never apply nest_asyncio here. It replaces asyncio.run and
+# run_until_complete process-wide, and its run_until_complete returns the moment
+# the root task finishes without running that task's done-callbacks. anyio stops
+# its worker threads from exactly such a callback, so any request that touched
+# the thread pool left a non-daemon worker parked forever and one-shot CLI
+# commands hung at interpreter exit on Python < 3.14 (#1333, #1345). Callers
+# already inside a running loop (pytest-asyncio, the API lifespan) take the
+# thread fallback in run_migrations_online(), the only path 3.14 ever used.
 
 # Trigger: only set test env when actually running under pytest
 # Why: alembic/env.py is imported during normal operations (MCP server startup, migrations)

basic_memory/deps/config.py

@@ -12,12 +12,16 @@ from fastapi import Depends, Request
 from basic_memory.config import BasicMemoryConfig
 
 
-def get_app_config(request: Request) -> BasicMemoryConfig:
+async def get_app_config(request: Request) -> BasicMemoryConfig:
     """Resolve the application configuration from the composition root.
 
     API requests read the container the lifespan stored on ``app.state``.
     Requests served without a lifespan (the CLI/MCP local ASGI flow) fall back
     to the API composition root, which creates a container on demand.
+
+    Declared ``async`` although it never awaits: FastAPI runs *sync* dependencies
+    on anyio's worker-thread pool, and an attribute read is not worth a thread
+    hop per request — nor the non-daemon worker it leaves parked (#1345).
     """
     container = getattr(request.app.state, "container", None)
     if container is not None:

basic_memory/deps/read_cache.py

@@ -12,8 +12,12 @@ from basic_memory.read_cache.policy import (
 )
 
 
-def get_read_cache(request: Request) -> ReadCache | None:
-    """Return the optional host-injected cache backend."""
+async def get_read_cache(request: Request) -> ReadCache | None:
+    """Return the optional host-injected cache backend.
+
+    ``async`` for the same reason as ``get_app_config``: a sync dependency would
+    hop to anyio's worker pool just to read an attribute (#1345).
+    """
     try:
         container = request.app.state.container
     except AttributeError:

basic_memory/markdown/plugins.py

@@ -5,6 +5,7 @@ from typing import List, Any, Dict
 
 from basic_memory.utils import normalize_project_reference
 from markdown_it import MarkdownIt
+from markdown_it.rules_inline.backticks import backtick
 from markdown_it.token import Token
 
 # Transcript timecodes like [00:00:11] or [1:02:03.500] share the bracket shape of
@@ -127,6 +128,84 @@ def parse_observation(token: Token) -> Dict[str, Any]:
 
 
 # Relation handling functions
+def _relation_content(token: Token) -> str:
+    """Return the source content of an inline token."""
+    return token.tag or token.content
+
+
+_CODE_SPANS_KEY = "basic_memory_code_spans"
+_CODE_SPAN_PARSER = MarkdownIt()
+
+
+def _record_inline_code_span(state: Any, silent: bool) -> bool:
+    """Delegate to MarkdownIt and retain exact source spans for code tokens."""
+    start = state.pos
+    token_count = len(state.tokens)
+    matched = backtick(state, silent)
+    if matched and not silent and len(state.tokens) > token_count:
+        if state.tokens[-1].type == "code_inline":
+            state.env[_CODE_SPANS_KEY].append((start, state.pos))
+    return matched
+
+
+_CODE_SPAN_PARSER.inline.ruler.at("backticks", _record_inline_code_span)
+
+
+def _inline_code_spans(content: str) -> list[tuple[int, int]]:
+    """Return source ranges that MarkdownIt classifies as inline code.
+
+    This delegates delimiter and escape handling to the same MarkdownIt inline
+    rule used by the document parser instead of duplicating CommonMark's
+    backtick scanner. It also preserves MarkdownIt's linear-time cache for
+    unmatched delimiter runs.
+    """
+    if "`" not in content:
+        return []
+
+    spans: list[tuple[int, int]] = []
+    _CODE_SPAN_PARSER.inline.parse(content, _CODE_SPAN_PARSER, {_CODE_SPANS_KEY: spans}, [])
+    return spans
+
+
+def _mask_wikilinks_in_inline_code(content: str, code_spans: list[tuple[int, int]]) -> str:
+    """Mask only brackets in code spans, retaining all non-link source text."""
+    if not code_spans:
+        return content
+
+    masked = list(content)
+    for start, end in code_spans:
+        for position in range(start, end):
+            if masked[position] in "[]":
+                masked[position] = " "
+
+    return "".join(masked)
+
+
+def _remove_links_to_directive_outside_inline_code(
+    content: str, code_spans: list[tuple[int, int]]
+) -> tuple[str, bool]:
+    """Remove a terminal directive only when MarkdownIt parsed it as non-code."""
+    directive_content = list(content)
+    for start, end in code_spans:
+        directive_content[start:end] = " " * (end - start)
+
+    match = _LINKS_TO_DIRECTIVE.search("".join(directive_content))
+    if not match:
+        return content, False
+    return content[: match.start()].rstrip(), True
+
+
+def _relation_parsing_content(token: Token) -> tuple[str, str, list[tuple[int, int]]]:
+    """Build source-preserving relation input from MarkdownIt's code spans."""
+    source_content = _relation_content(token)
+    code_spans = _inline_code_spans(source_content)
+    return (
+        source_content,
+        _mask_wikilinks_in_inline_code(source_content, code_spans),
+        code_spans,
+    )
+
+
 def parse_relation_type(content: str) -> str | None:
     """Return the explicit relation label before the first wikilink, if any."""
     before_link = content.partition("[[")[0].strip()
@@ -154,15 +233,17 @@ def is_explicit_relation(token: Token) -> bool:
     if token.type != "inline":  # pragma: no cover
         return False
 
-    # Use token.tag which contains the actual content for test tokens, fallback to content
-    content = (token.tag or token.content).strip()
+    _, content, _ = _relation_parsing_content(token)
     if "[[" not in content or "]]" not in content:
         return False
     return _parse_explicit_relation(content) is not None
 
 
-def _parse_explicit_relation(content: str) -> Dict[str, Any] | None:
+def _parse_explicit_relation(
+    content: str, source_content: str | None = None
+) -> Dict[str, Any] | None:
     """Parse ``type [[target]] (context)``, rejecting lines with a prose tail."""
+    source_content = source_content or content
     rel_type = parse_relation_type(content)
     if rel_type is None:
         return None
@@ -172,7 +253,7 @@ def _parse_explicit_relation(content: str) -> Dict[str, Any] | None:
     if start == -1 or end == -1:
         return None
 
-    target = normalize_project_reference(content[start + 2 : end].strip())
+    target = normalize_project_reference(source_content[start + 2 : end].strip())
     if not target:
         return None
 
@@ -189,7 +270,8 @@ def _parse_explicit_relation(content: str) -> Dict[str, Any] | None:
     if after:
         if not _is_single_parenthesized(after):
             return None
-        context = after[1:-1].strip() or None
+        source_after = source_content[end + 2 :].strip()
+        context = source_after[1:-1].strip() or None
 
     return {"type": rel_type, "target": target, "context": context}
 
@@ -217,13 +299,23 @@ def _is_single_parenthesized(text: str) -> bool:
 
 def parse_relation(token: Token) -> Dict[str, Any] | None:
     """Extract relation parts from token."""
-    # Use token.tag which contains the actual content for test tokens, fallback to content
-    content = (token.tag or token.content).strip()
-    return _parse_explicit_relation(content)
+    source_content, content, _ = _relation_parsing_content(token)
+    return _parse_explicit_relation(content, source_content)
+
 
+def _is_escaped(content: str, position: int) -> bool:
+    """Whether the character at ``position`` is escaped by an odd slash run."""
+    slash_count = 0
+    position -= 1
+    while position >= 0 and content[position] == "\\":
+        slash_count += 1
+        position -= 1
+    return slash_count % 2 == 1
 
-def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
-    """Find wiki-style links in regular content."""
+
+def parse_inline_relations(content: str, source_content: str | None = None) -> List[Dict[str, Any]]:
+    """Find wiki-style links, extracting targets from the original source."""
+    source_content = content if source_content is None else source_content
     relations = []
     start = 0
 
@@ -232,6 +324,9 @@ def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
         start = content.find("[[", start)
         if start == -1:  # pragma: no cover
             break
+        if _is_escaped(content, start):
+            start += 2
+            continue
 
         # Find matching ]]
         depth = 1
@@ -239,10 +334,10 @@ def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
         end = -1
 
         while pos < len(content):
-            if content[pos : pos + 2] == "[[":
+            if content[pos : pos + 2] == "[[" and not _is_escaped(content, pos):
                 depth += 1
                 pos += 2
-            elif content[pos : pos + 2] == "]]":
+            elif content[pos : pos + 2] == "]]" and not _is_escaped(content, pos):
                 depth -= 1
                 if depth == 0:
                     end = pos
@@ -255,7 +350,7 @@ def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
             # No matching ]] found
             break
 
-        target = normalize_project_reference(content[start + 2 : end].strip())
+        target = normalize_project_reference(source_content[start + 2 : end].strip())
         if target:
             relations.append({"type": "links_to", "target": target, "context": None})
 
@@ -336,21 +431,27 @@ def relation_plugin(md: MarkdownIt) -> None:
 
             # Only process inline tokens
             if token.type == "inline":
-                content = token.tag or token.content
-                content_without_directive, has_directive = remove_links_to_directive(content)
+                source_content = _relation_content(token)
+                if "[[" not in source_content:
+                    continue
+
+                code_spans = _inline_code_spans(source_content)
+                relation_content = _mask_wikilinks_in_inline_code(source_content, code_spans)
+                content_without_directive, has_directive = (
+                    _remove_links_to_directive_outside_inline_code(relation_content, code_spans)
+                )
 
                 # Check for explicit relations in list items
-                if in_list_item and not has_directive and is_explicit_relation(token):
-                    rel = parse_relation(token)
+                if in_list_item and not has_directive:
+                    rel = _parse_explicit_relation(relation_content, source_content)
                     if rel:
                         token.meta["relations"] = [rel]
+                        continue
 
                 # Always check for inline links in any text
-                else:
-                    if "[[" in content:
-                        rels = parse_inline_relations(content_without_directive)
-                        if rels:
-                            token.meta["relations"] = token.meta.get("relations", []) + rels
+                rels = parse_inline_relations(content_without_directive, source_content)
+                if rels:
+                    token.meta["relations"] = token.meta.get("relations", []) + rels
 
     # Add the rule after inline processing
     md.core.ruler.after("inline", "relations", relation_rule)

{basic_memory-0.23.2.dev3.dist-info → basic_memory-0.23.3.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: basic-memory
-Version: 0.23.2.dev3
+Version: 0.23.3.dev2
 Summary: Local-first knowledge management combining Zettelkasten with knowledge graphs
 Project-URL: Homepage, https://github.com/basicmachines-co/basic-memory
 Project-URL: Repository, https://github.com/basicmachines-co/basic-memory
@@ -29,7 +29,6 @@ Requires-Dist: mcp<3,>=2
 Requires-Dist: mdformat-frontmatter>=2.0.8
 Requires-Dist: mdformat-gfm>=0.3.7
 Requires-Dist: mdformat>=0.7.22
-Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: openai>=1.100.2
 Requires-Dist: pillow>=11.1.0
 Requires-Dist: psutil>=5.9.0

{basic_memory-0.23.2.dev3.dist-info → basic_memory-0.23.3.dev2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-basic_memory/__init__.py,sha256=rHK-KinfjZzEkeUVmFnT-996yse86yhhjCpaHBNCd9k,256
+basic_memory/__init__.py,sha256=dtmjVy3Q4_DYddSDwS9XOq3okErGMfYtVZ-_1s5p2zQ,256
 basic_memory/config.py,sha256=gPw1piQZJANYCF-TkpEpc9-vD7-lHnSez8HQidGh5qk,12080
 basic_memory/config_logging.py,sha256=keqWv5xPOP6fjh1LDQmKMDyduHTYAhr6Y1EKiiYVDnc,1857
 basic_memory/config_migrations.py,sha256=OO5hwzs3x5EEix-jNMeETrJQwMx0l2iHUywXRLMjzFA,3582
@@ -6,14 +6,13 @@ basic_memory/config_models.py,sha256=TehggqA0vm9eVo9rQugAXyTmQ-R_BJVriNl8niMiVw0
 basic_memory/db.py,sha256=STYA6RmCWXFaF3ZhC0_ay0Q8B2V_htrOFo6YQcW528Q,25977
 basic_memory/file_utils.py,sha256=_cIrb3xebx2wDdoHvvIWWgA9yfePc4TDuAAnks3Dges,18540
 basic_memory/ignore_utils.py,sha256=1OoKxiS7_ofYYHWTtH5zoUVeaMJ8-V7j0dsqxYA3dDo,8486
-basic_memory/migration_loop.py,sha256=KGhuCLgrgwW21GAGT9cOczbtRlM4mGi7aUBjG1shQ8s,1609
 basic_memory/project_resolver.py,sha256=vHWHw1X9_1IqtX9Dy5yNXqNRas3wcrpQJVKxJuj4qWg,3801
 basic_memory/redaction.py,sha256=tYolNeRQdOfcELD9sGtzQbB5dS3odP9PAnzipqmMl6M,4804
 basic_memory/telemetry.py,sha256=pAkPgbAOmivZDkCAW0S2CKSNw4AqBfMckdsbb2EipcQ,1721
 basic_memory/utils.py,sha256=bXlhv3qHOO_1Lb_2gUspjOZ3H1-qgreWl_n5eR6_Jxg,35426
 basic_memory/workspace_context.py,sha256=v-u4jO8VFB1WeFZ1UpzZnbf9ph71vvz1OMibpAtrtQI,3648
 basic_memory/alembic/alembic.ini,sha256=IEZsnF8CbbZnkwBr67LzKKNobHuzTaQNUvM8Psop5xc,3733
-basic_memory/alembic/env.py,sha256=ZfUWoJeIJKTCsOSvz6mty0c570k2k4MF9cvi7T4sj1g,9581
+basic_memory/alembic/env.py,sha256=26K_F2KEvz3SneUQ5LuHCpvZ1FD1w9s1wP63lQFDNZI,9275
 basic_memory/alembic/migrations.py,sha256=lriHPXDdBLSNXEW3QTpU0SJKuVd1V-8NrVkpN3qfsUQ,718
 basic_memory/alembic/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 basic_memory/alembic/versions/2d26b287813b_dedupe_observations_and_purge_stale_.py,sha256=h-Q0g5g2r3GmXWK49RyxvmvHGd5idVGA4VYkK4LYTek,2139
@@ -115,11 +114,11 @@ basic_memory/cli/commands/cloud/webdav.py,sha256=5yanr7lQy6dv8RVvixI0k_3HpCOnyzV
 basic_memory/cli/commands/cloud/webdav_transfer.py,sha256=ncj_eLthaN7a8-eKyieBxHoBqg3SaXVXIs6K8_UGw2Q,23340
 basic_memory/cli/commands/cloud/workspace.py,sha256=08TdcYohmDunprmUgpGO4SvCjD7A_vynBYIkD2LNooc,3940
 basic_memory/deps/__init__.py,sha256=thQt1C04eNMA49Y3OubiIiv0WIWie75aCd4TBTMkddE,6139
-basic_memory/deps/config.py,sha256=FjhA3OVWf0U0n9BzYnxSn5MXdgq-mMGxxhgzHjIgBgo,1200
+basic_memory/deps/config.py,sha256=zQrYU7K6XIFflvi8VYFmbEhIJ5GDQXoqHZ9SFWoLKQg,1444
 basic_memory/deps/db.py,sha256=xpD5Mcq16f8J0lbu8PCoRcr2s4e1xKOj1nze_NW3CGg,2395
 basic_memory/deps/importers.py,sha256=G2ulW2xdexR4indqlNYqt9kzoQCtSqnPcRgb-ae4Cuo,3786
 basic_memory/deps/projects.py,sha256=z2Qziv58GJw-I4CofIiIXeyXBVtYHAcd-dep5Fg2slw,3352
-basic_memory/deps/read_cache.py,sha256=fcwfzvqS5b4aNBxcLjCPNlKvMYj3ndxyHcOd4vFJkOM,1400
+basic_memory/deps/read_cache.py,sha256=l6yJCUWkW2kHhK80GqzPMSJDwEe6wqWFC7gOgJg_YY8,1559
 basic_memory/deps/repositories.py,sha256=2ZQeScK-C3VOnYs_re0FCAty5cEz3PpTPnSxtW_gFqQ,2750
 basic_memory/deps/services.py,sha256=cjxsFhVTwqmf-nUUv3SdEKM-UXBf8OH0oQ9Dj5HO7RY,21096
 basic_memory/hooks/__init__.py,sha256=kEvNW8tpXcnTdzwUpjoir2RZxVXRULJhB38WGwDKCHc,861
@@ -207,7 +206,7 @@ basic_memory/man/bm.1,sha256=iQhnHzJHSN3WRdMIphv22AnWTYR2SErzeKwCqQJ3LzQ,3406
 basic_memory/markdown/__init__.py,sha256=DdzioCWtDnKaq05BHYLgL_78FawEHLpLXnp-kPSVfIc,501
 basic_memory/markdown/entity_parser.py,sha256=7RUL7QXOQc00ez7OFOJB6kvsD8yY6K_yVD4VGSHOPxc,12629
 basic_memory/markdown/markdown_processor.py,sha256=YK8KF8NY0N9nQM3I_8Pcxybf5SPOPnIL5kzmFBFBlx0,7429
-basic_memory/markdown/plugins.py,sha256=y_gfzywOC4r-WNTYPPnn-Px0eiCTwdm2MJnFXJEfIwg,12831
+basic_memory/markdown/plugins.py,sha256=US8WhuZVfElSPGlSjP8_8C1J_dvasc6EjZJAF7-QvZ8,16464
 basic_memory/markdown/schemas.py,sha256=IHi4sm40ew4zNjb359imwiPJXGO6cIni_1f3YNVyZPs,2798
 basic_memory/markdown/utils.py,sha256=EP8P8uDNrhcnvpgc_iaczIQK3r9Z6k1MHMKCcZvTzm0,4122
 basic_memory/mcp/__init__.py,sha256=dsDOhKqjYeIbCULbHIxfcItTbqudEuEg1Np86eq0GEQ,35
@@ -391,8 +390,8 @@ basic_memory/services/search_service.py,sha256=8A1vXo5IIpKXL2gxEsCEP_tcKyRcnz4R5
 basic_memory/services/service.py,sha256=V-d_8gOV07zGIQDpL-Ksqs3ZN9l3qf3HZOK1f_YNTag,336
 basic_memory/templates/prompts/continue_conversation.hbs,sha256=trrDHSXA5S0JCbInMoUJL04xvCGRB_ku1RHNQHtl6ZI,3076
 basic_memory/templates/prompts/search.hbs,sha256=H1cCIsHKp4VC1GrH2KeUB8pGe5vXFPqb2VPotypmeCA,3098
-basic_memory-0.23.2.dev3.dist-info/METADATA,sha256=g1nFCTGZ2YGR6nRflPOqiOMpWI_8Ew2oJHYpIj7ji3Q,26847
-basic_memory-0.23.2.dev3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-basic_memory-0.23.2.dev3.dist-info/entry_points.txt,sha256=wvE2mRF6-Pg4weIYcfQ-86NOLZD4WJg7F7TIsRVFLb8,90
-basic_memory-0.23.2.dev3.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-basic_memory-0.23.2.dev3.dist-info/RECORD,,
+basic_memory-0.23.3.dev2.dist-info/METADATA,sha256=_c99-bcBWDk2nBo5pqbUCMbUVlYnl3TV2vtXjWFolGk,26812
+basic_memory-0.23.3.dev2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+basic_memory-0.23.3.dev2.dist-info/entry_points.txt,sha256=wvE2mRF6-Pg4weIYcfQ-86NOLZD4WJg7F7TIsRVFLb8,90
+basic_memory-0.23.3.dev2.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+basic_memory-0.23.3.dev2.dist-info/RECORD,,

basic_memory/migration_loop.py

@@ -1,34 +0,0 @@
-"""Pure helpers for how Alembic bridges async migrations across event loops.
-
-Extracted from ``alembic/env.py`` so these two decisions are unit-testable:
-env.py runs migrations at import time and cannot be imported in a test, but the
-loop-detection and error-classification logic is exactly what regresses, so it
-lives here where it can be covered directly.
-"""
-
-from __future__ import annotations
-
-import asyncio
-
-
-def running_on_uvloop() -> bool:
-    """Return True when the active asyncio policy is uvloop.
-
-    The Postgres backend installs the uvloop policy before the event loop starts
-    (#831/#877). nest_asyncio cannot patch a uvloop loop, but depending on the
-    nest_asyncio version ``apply()`` may NOT raise the ValueError we expect — it
-    can silently mis-patch the stdlib loop instead. The later ``asyncio.run()``
-    then fails with "this event loop is already running" rather than the standard
-    "cannot be called from a running event loop", which the thread-based fallback
-    would not recognize, crashing startup. Detecting uvloop up front lets env.py
-    skip nest_asyncio entirely and stay on the standard running-loop error path.
-    """
-    try:
-        import uvloop
-    except ImportError:
-        return False
-    # Constraint: on supported Python 3.12-3.13 this helper runs before a loop
-    # exists, so the active policy is the only observable uvloop signal. Python
-    # 3.14+ skips this helper in alembic/env.py; remove it with the policy seam.
-    policy = asyncio.get_event_loop_policy()  # ty: ignore[deprecated]
-    return isinstance(policy, uvloop.EventLoopPolicy)