basic-memory 0.23.1.dev2__py3-none-any.whl → 0.23.1.dev20__py3-none-any.whl

basic_memory/alembic/versions/7f6a2b8c9d10_index_full_postgres_note_content.py

@@ -0,0 +1,77 @@
+"""Index complete PostgreSQL note content for full-text search.
+
+Revision ID: 7f6a2b8c9d10
+Revises: 2d26b287813b
+Create Date: 2026-08-24 22:00:00.000000
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision: str = "7f6a2b8c9d10"
+down_revision: Union[str, None] = "2d26b287813b"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Index complete note bodies as bounded PostgreSQL FTS chunks."""
+    connection = op.get_bind()
+    if connection.dialect.name == "postgresql":
+        op.execute("""
+            CREATE TABLE search_index_fts_chunks (
+                project_id INTEGER NOT NULL,
+                search_index_id INTEGER NOT NULL,
+                search_index_type VARCHAR NOT NULL,
+                chunk_index INTEGER NOT NULL,
+                chunk_text TEXT NOT NULL,
+                textsearchable_index_col tsvector GENERATED ALWAYS AS (
+                    to_tsvector('english', chunk_text)
+                ) STORED,
+                PRIMARY KEY (project_id, search_index_id, search_index_type, chunk_index),
+                FOREIGN KEY (search_index_id, search_index_type, project_id)
+                    REFERENCES search_index(id, type, project_id)
+                    ON UPDATE CASCADE ON DELETE CASCADE
+            )
+        """)
+        op.execute("""
+            -- PostgreSQL ignores lexemes at 2 KiB and above. Stepping 5,952
+            -- characters leaves a conservative 2,048-character overlap, so
+            -- every indexable lexeme split at one edge is complete in the next.
+            INSERT INTO search_index_fts_chunks (
+                project_id,
+                search_index_id,
+                search_index_type,
+                chunk_index,
+                chunk_text
+            )
+            SELECT
+                search_index.project_id,
+                search_index.id,
+                search_index.type,
+                (chunk_start - 1) / 5952,
+                substring(search_index.content_snippet FROM chunk_start FOR 8000)
+            FROM search_index
+            CROSS JOIN LATERAL generate_series(
+                1,
+                length(search_index.content_snippet),
+                5952
+            ) AS chunk_start
+            WHERE search_index.content_snippet IS NOT NULL
+              AND search_index.content_snippet <> ''
+        """)
+        op.execute("""
+            CREATE INDEX idx_search_index_fts_chunks_fts
+            ON search_index_fts_chunks USING gin(textsearchable_index_col)
+        """)
+
+
+def downgrade() -> None:
+    """Remove the bounded full-content PostgreSQL FTS chunks."""
+    connection = op.get_bind()
+    if connection.dialect.name == "postgresql":
+        op.execute("DROP TABLE IF EXISTS search_index_fts_chunks")

basic_memory/cli/auto_update.py

@@ -221,6 +221,38 @@ def _preload_lazy_console_modules() -> None:
     """
     import rich._emoji_codes  # noqa: F401
     import typer.rich_utils  # noqa: F401
+    from rich.cells import cell_len
+
+    # Trigger: rich defers its Unicode cell-width table (`rich._unicode_data.
+    # unicode<version>`) until the first character it cannot measure with the
+    # ASCII fast path in `_cell_len`.
+    # Why: status messages echo captured `brew`/`uv` output, which carries
+    # non-ASCII characters (curly quotes, em dashes, warning glyphs), so the
+    # deferred import lands after the upgrade removed our files. Importing the
+    # module by name would hard-code a table version; calling `cell_len` uses
+    # rich's own resolution and honors UNICODE_VERSION like the print path does.
+    # Outcome: the table rich will reach for is resolved and cached up front.
+    cell_len("\u2500\u2018\u2713")
+
+
+def print_update_status(console: Console, text: str, style: str) -> None:
+    """Print an update status line that cannot fail the command.
+
+    Trigger: the line is printed after an in-place upgrade may already have
+    replaced this installation on disk.
+    Why: `_preload_lazy_console_modules` can only preload the deferred imports
+    we know about today, and rich/typer are free to add more. By the time this
+    prints, the upgrade has already succeeded -- a status line must never be
+    what turns it into a traceback and a non-zero exit.
+    Outcome: fall back to a plain, unstyled write that needs no new imports.
+    """
+    try:
+        console.print(f"[{style}]{text}[/{style}]")
+    except Exception as exc:
+        logger.warning(
+            f"Rich console print failed after update, falling back to plain output: {exc}"
+        )
+        print(text)
 
 
 def _save_last_checked_timestamp(config_manager: ConfigManager, checked_at: datetime) -> None:
@@ -468,11 +500,11 @@ def maybe_run_periodic_auto_update(
     }:
         out = console or Console()
         if result.status == AutoUpdateStatus.UPDATED:
-            out.print(f"[green]{result.message}[/green]")
+            print_update_status(out, f"{result.message}", "green")
         elif result.status == AutoUpdateStatus.FAILED:
             error_detail = f" {result.error}" if result.error else ""
-            out.print(f"[yellow]{result.message}{error_detail}[/yellow]")
+            print_update_status(out, f"{result.message}{error_detail}", "yellow")
         elif result.message:
-            out.print(f"[cyan]{result.message}[/cyan]")
+            print_update_status(out, f"{result.message}", "cyan")
 
     return result

basic_memory/cli/commands/doctor.py

@@ -81,6 +81,23 @@ async def _delete_doctor_project(
         await _delete_doctor_project_locally(project_name, project_id)
 
 
+async def _read_materialized_api_note(api_file: Path, file_path: str) -> str:
+    """Wait for the accepted local write, then read its canonical file."""
+    # Deferred: importing the materialization runtime at CLI module load would slow every
+    # command, while doctor is the only command that needs to observe its write immediately.
+    from basic_memory.index.note_content_materialization import drain_pending_materializations
+
+    # Trigger: production accepts note content before its markdown file is materialized.
+    # Why: doctor verifies the complete DB -> file contract, not only write acceptance.
+    # Outcome: wait for the same deferred work drained at normal CLI shutdown before checking.
+    await drain_pending_materializations()
+
+    if not api_file.exists():
+        raise ValueError(f"API note file missing: {file_path}")
+
+    return api_file.read_text(encoding="utf-8")
+
+
 async def run_doctor() -> None:
     """Run local consistency checks for file <-> database flows."""
     # Deferred: the markdown parsing stack is only needed while the checks run,
@@ -132,10 +149,7 @@ async def run_doctor() -> None:
                 api_result = await knowledge_client.create_entity(api_note.model_dump())
 
                 api_file = project_path / api_result.file_path
-                if not api_file.exists():
-                    raise ValueError(f"API note file missing: {api_result.file_path}")
-
-                api_text = api_file.read_text(encoding="utf-8")
+                api_text = await _read_materialized_api_note(api_file, api_result.file_path)
                 if api_note_title not in api_text:
                     raise ValueError("API note content missing from file")
 

basic_memory/cli/commands/update.py

@@ -4,7 +4,7 @@ import typer
 from rich.console import Console
 
 from basic_memory.cli.app import app
-from basic_memory.cli.auto_update import AutoUpdateStatus, run_auto_update
+from basic_memory.cli.auto_update import AutoUpdateStatus, print_update_status, run_auto_update
 
 console = Console()
 
@@ -22,19 +22,21 @@ def update(
 
     if result.status == AutoUpdateStatus.FAILED:
         detail = f" {result.error}" if result.error else ""
-        console.print(f"[red]{result.message or 'Update failed.'}{detail}[/red]")
+        print_update_status(console, f"{result.message or 'Update failed.'}{detail}", "red")
         raise typer.Exit(1)
 
     if result.status == AutoUpdateStatus.UPDATED:
-        console.print(f"[green]{result.message or 'Basic Memory updated successfully.'}[/green]")
+        print_update_status(
+            console, f"{result.message or 'Basic Memory updated successfully.'}", "green"
+        )
         return
 
     if result.status == AutoUpdateStatus.UP_TO_DATE:
-        console.print(f"[green]{result.message or 'Basic Memory is up to date.'}[/green]")
+        print_update_status(console, f"{result.message or 'Basic Memory is up to date.'}", "green")
         return
 
     if result.status == AutoUpdateStatus.UPDATE_AVAILABLE:
-        console.print(f"[cyan]{result.message or 'Update available.'}[/cyan]")
+        print_update_status(console, f"{result.message or 'Update available.'}", "cyan")
         return
 
-    console.print(f"[dim]{result.message or 'No update action was performed.'}[/dim]")
+    print_update_status(console, f"{result.message or 'No update action was performed.'}", "dim")

basic_memory/markdown/plugins.py

@@ -13,6 +13,15 @@ from markdown_it.token import Token
 # those bracket prefixes stay ordinary content (issue #1219).
 _TIMESTAMP_VALUE = r"\d{1,3}:\d{2}(?::\d{2})?(?:[.,]\d{1,3})?"
 _TIMESTAMP_CATEGORY = re.compile(rf"^{_TIMESTAMP_VALUE}(?:\s+-\s+{_TIMESTAMP_VALUE})?$")
+_LINKS_TO_DIRECTIVE = re.compile(r"\s+#bm:links_to\s*$")
+
+
+def remove_links_to_directive(content: str) -> tuple[str, bool]:
+    """Remove an exact terminal ``#bm:links_to`` directive from content."""
+    match = _LINKS_TO_DIRECTIVE.search(content)
+    if not match:
+        return content, False
+    return content[: match.start()].rstrip(), True
 
 
 def _is_task_marker_category(category: str) -> bool:
@@ -47,6 +56,7 @@ def is_observation(token: Token) -> bool:
         return False
     # Use token.tag which contains the actual content for test tokens, fallback to content
     content = (token.tag or token.content).strip()
+    content, _ = remove_links_to_directive(content)
     if not content:  # pragma: no cover
         return False
     # if it's a markdown_task, return false
@@ -74,6 +84,7 @@ def parse_observation(token: Token) -> Dict[str, Any]:
 
     # Use token.tag which contains the actual content for test tokens, fallback to content
     content = (token.tag or token.content).strip()
+    content, _ = remove_links_to_directive(content)
 
     # Parse [category] with regex; a timestamp-shaped prefix is not a category, so a
     # hashtag-promoted transcript line keeps its timecode inside the content instead.
@@ -325,17 +336,19 @@ 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)
+
                 # Check for explicit relations in list items
-                if in_list_item and is_explicit_relation(token):
+                if in_list_item and not has_directive and is_explicit_relation(token):
                     rel = parse_relation(token)
                     if rel:
                         token.meta["relations"] = [rel]
 
                 # Always check for inline links in any text
                 else:
-                    content = token.tag or token.content
                     if "[[" in content:
-                        rels = parse_inline_relations(content)
+                        rels = parse_inline_relations(content_without_directive)
                         if rels:
                             token.meta["relations"] = token.meta.get("relations", []) + rels
 

basic_memory/mcp/tools/write_note.py

@@ -109,12 +109,15 @@ async def write_note(
         - Explicit: `- relation_type [[Entity]] (optional context)`
         - Quoted: `- "multi word relation type" [[Entity]] (optional context)`
         - Quoted: `- 'multi word relation type' [[Entity]] (optional context)`
+        - Disambiguation: Add `#bm:links_to` when prose before `[[Entity]]`
+          must not be treated as a single-token relation type
         - Inline: Any other `[[Entity]]` reference creates a `links_to` relation
 
         Examples:
         `- depends_on [[Content Parser]] (Need for semantic extraction)`
         `- "based on" [[Design Notes]]`
         `- 'in response to' [[Incident Review]]`
+        `- Mother [[Alice]] #bm:links_to`
         `- implements [[Search Spec]] (Initial implementation)`
         `- This feature extends [[Base Design]] and uses [[Core Utils]]`
 

basic_memory/models/search.py

@@ -33,7 +33,11 @@ CREATE TABLE IF NOT EXISTS search_index (
     created_at TIMESTAMP WITH TIME ZONE,
     updated_at TIMESTAMP WITH TIME ZONE,
     textsearchable_index_col tsvector GENERATED ALWAYS AS (
-        to_tsvector('english', coalesce(title, '') || ' ' || coalesce(content_stems, ''))
+        to_tsvector(
+            'english',
+            coalesce(title, '') || ' ' ||
+            coalesce(content_stems, '')
+        )
     ) STORED,
     PRIMARY KEY (id, type, project_id),
     FOREIGN KEY (project_id) REFERENCES project(id) ON DELETE CASCADE
@@ -44,6 +48,30 @@ CREATE_POSTGRES_SEARCH_INDEX_FTS = DDL("""
 CREATE INDEX IF NOT EXISTS idx_search_index_fts ON search_index USING gin(textsearchable_index_col)
 """)
 
+# Full note bodies are stored in bounded child rows so one unusually large note
+# cannot exceed PostgreSQL's per-tsvector size limit.
+CREATE_POSTGRES_SEARCH_INDEX_FTS_CHUNKS_TABLE = DDL("""
+CREATE TABLE IF NOT EXISTS search_index_fts_chunks (
+    project_id INTEGER NOT NULL,
+    search_index_id INTEGER NOT NULL,
+    search_index_type VARCHAR NOT NULL,
+    chunk_index INTEGER NOT NULL,
+    chunk_text TEXT NOT NULL,
+    textsearchable_index_col tsvector GENERATED ALWAYS AS (
+        to_tsvector('english', chunk_text)
+    ) STORED,
+    PRIMARY KEY (project_id, search_index_id, search_index_type, chunk_index),
+    FOREIGN KEY (search_index_id, search_index_type, project_id)
+        REFERENCES search_index(id, type, project_id)
+        ON UPDATE CASCADE ON DELETE CASCADE
+)
+""")
+
+CREATE_POSTGRES_SEARCH_INDEX_FTS_CHUNKS_INDEX = DDL("""
+CREATE INDEX IF NOT EXISTS idx_search_index_fts_chunks_fts
+ON search_index_fts_chunks USING gin(textsearchable_index_col)
+""")
+
 CREATE_POSTGRES_SEARCH_INDEX_METADATA = DDL("""
 CREATE INDEX IF NOT EXISTS idx_search_index_metadata_gin ON search_index USING gin(metadata jsonb_path_ops)
 """)

basic_memory/repository/postgres_search_repository.py

@@ -45,6 +45,66 @@ from basic_memory.repository.pgvector_index import PgVectorIndex
 from basic_memory.schemas.search import SearchItemType, SearchRetrievalMode
 
 
+POSTGRES_FTS_CHUNK_SIZE = 8_000
+# PostgreSQL ignores lexemes at 2 KiB and above. A 2,048-character overlap is
+# therefore conservative for every indexable lexeme, including multi-byte text:
+# any token split at one 8,000-character edge is complete in the next chunk.
+POSTGRES_FTS_CHUNK_OVERLAP = 2_048
+_TSQUERY_OPERAND_PATTERN = re.compile(r"'(?:''|[^'])*'(?::\*)?|[^\s&|!()]+")
+_TSQUERY_WORD_PATTERN = re.compile(r"[^\W_]+(?:'[^\W_]+)?", re.UNICODE)
+
+
+def _iter_fts_chunks(content: str | None) -> list[tuple[int, str]]:
+    """Split full note text without losing an indexable lexeme at a chunk edge."""
+    if not content:
+        return []
+
+    step = POSTGRES_FTS_CHUNK_SIZE - POSTGRES_FTS_CHUNK_OVERLAP
+    return [
+        (chunk_index, content[start : start + POSTGRES_FTS_CHUNK_SIZE])
+        for chunk_index, start in enumerate(range(0, len(content), step))
+    ]
+
+
+def _tsquery_operands(processed_text: str) -> list[tuple[str, str]]:
+    """Return unique (query operand, representative text) pairs in source order."""
+    operands: dict[str, str] = {}
+    for operand in _TSQUERY_OPERAND_PATTERN.findall(processed_text):
+        representative = operand.removesuffix(":*")
+        if representative.startswith("'") and representative.endswith("'"):
+            representative = representative[1:-1].replace("''", "'")
+            operands.setdefault(operand, representative)
+            continue
+
+        # An unquoted apostrophe is invalid tsquery syntax. Keep the literal
+        # word for the synthetic document, but quote and escape its probe so a
+        # strict syntax failure can proceed to the relaxed retry.
+        if "'" in representative:
+            escaped = "'{}'".format(representative.replace("'", "''"))
+            safe_operand = f"{escaped}:*" if operand.endswith(":*") else escaped
+            operands.setdefault(safe_operand, representative)
+            continue
+
+        # PostgreSQL legitimately parses punctuation inside operands such as
+        # ``v0.13.0b2:*`` and ``auth-service:*``. Preserve those bytes so the
+        # synthetic document is tokenized the same way as the original note.
+        if "<" not in representative and ">" not in representative:
+            operands.setdefault(operand, representative)
+            continue
+
+        # A malformed strict operand (for example ``foo<bar:*``) must not poison
+        # the later relaxed retry. Split punctuation into the same safe word pieces
+        # that PostgreSQL will lex, while the original full tsquery still determines
+        # whether the strict attempt raises and falls back.
+        is_prefix = operand.endswith(":*")
+        words = _TSQUERY_WORD_PATTERN.findall(representative)
+        for word in words or [representative]:
+            escaped_word = "'{}'".format(word.replace("'", "''")) if "'" in word else word
+            safe_operand = f"{escaped_word}:*" if is_prefix else escaped_word
+            operands.setdefault(safe_operand, word)
+    return list(operands.items())
+
+
 def _strip_nul_from_row(row_data: dict[str, Any]) -> dict[str, Any]:
     """Strip NUL bytes from all string values in a row dict.
 
@@ -199,9 +259,76 @@ class PostgresSearchRepository(SearchRepositoryBase):
                 """),
                 insert_data,
             )
+            await self._replace_fts_chunks(session, [search_index_row])
             logger.debug(f"indexed row {search_index_row}")
             await session.commit()
 
+    async def _replace_fts_chunks(
+        self,
+        session: AsyncSession,
+        search_index_rows: Sequence[SearchIndexRow],
+    ) -> None:
+        """Replace bounded full-content FTS rows for one indexing batch."""
+        if not search_index_rows:
+            return
+
+        await session.execute(
+            text("""
+                DELETE FROM search_index_fts_chunks
+                WHERE project_id = :project_id
+                  AND (search_index_id, search_index_type) IN (
+                      SELECT search_index_id, search_index_type
+                      FROM unnest(
+                          CAST(:search_index_ids AS INTEGER[]),
+                          CAST(:search_index_types AS VARCHAR[])
+                      ) AS indexed_rows(search_index_id, search_index_type)
+                  )
+            """),
+            {
+                "project_id": self.project_id,
+                "search_index_ids": [row.id for row in search_index_rows],
+                "search_index_types": [row.type for row in search_index_rows],
+            },
+        )
+
+        chunks = [
+            {
+                "search_index_id": row.id,
+                "search_index_type": row.type,
+                "chunk_index": chunk_index,
+                "chunk_text": chunk_text.replace("\x00", ""),
+            }
+            for row in search_index_rows
+            for chunk_index, chunk_text in _iter_fts_chunks(row.content_snippet)
+        ]
+        if not chunks:
+            return
+
+        await session.execute(
+            text("""
+                INSERT INTO search_index_fts_chunks (
+                    project_id,
+                    search_index_id,
+                    search_index_type,
+                    chunk_index,
+                    chunk_text
+                )
+                SELECT
+                    :project_id,
+                    chunk.search_index_id,
+                    chunk.search_index_type,
+                    chunk.chunk_index,
+                    chunk.chunk_text
+                FROM jsonb_to_recordset(CAST(:chunks AS JSONB)) AS chunk(
+                    search_index_id INTEGER,
+                    search_index_type VARCHAR,
+                    chunk_index INTEGER,
+                    chunk_text TEXT
+                )
+            """),
+            {"project_id": self.project_id, "chunks": json.dumps(chunks)},
+        )
+
     # ------------------------------------------------------------------
     # tsquery preparation (backend-specific)
     # ------------------------------------------------------------------
@@ -657,6 +784,7 @@ class PostgresSearchRepository(SearchRepositoryBase):
                 """),
                 insert_data_list,
             )
+            await self._replace_fts_chunks(session, search_index_rows)
             logger.debug(f"Bulk indexed {len(search_index_rows)} rows")
             await session.commit()
 
@@ -685,12 +813,14 @@ class PostgresSearchRepository(SearchRepositoryBase):
         search_item_types: Optional[List[SearchItemType]] = None,
         categories: Optional[List[str]] = None,
         metadata_filters: Optional[dict[str, Any]] = None,
+        allow_relaxed: bool = False,
     ) -> tuple[str, str, dict[str, Any], str, str]:
         """Build Postgres FTS FROM/WHERE params shared by search and count."""
         conditions = []
         params = {}
         order_by_clause = ""
         from_clause = "search_index"
+        document_vector_sql: str | None = None
 
         # Handle text search for title and content using tsvector
         if search_text:
@@ -701,10 +831,61 @@ class PostgresSearchRepository(SearchRepositoryBase):
                 # Prepare search term for tsquery
                 processed_text = self._prepare_search_term(search_text.strip())
                 params["text"] = processed_text
-                # Use @@ operator for tsvector matching
-                conditions.append(
-                    "search_index.textsearchable_index_col @@ to_tsquery('english', :text)"
-                )
+                probe_texts = [processed_text]
+                if allow_relaxed:
+                    relaxed_text = self._relaxed_tsquery_text(search_text)
+                    if relaxed_text:
+                        probe_texts.append(relaxed_text)
+
+                candidate_operands: dict[str, None] = {}
+                for probe_text in probe_texts:
+                    for operand, _representative in _tsquery_operands(probe_text):
+                        candidate_operands.setdefault(operand, None)
+                if candidate_operands:
+                    params["text_candidate"] = " | ".join(candidate_operands)
+
+                    # Trigger: PostgreSQL can extract a required-positive query tree.
+                    # Why: OR-ing its operands is a safe indexed superset even when
+                    # terms live in different chunks. Pure/optional negation returns
+                    # ``T`` and must retain all project rows for correct semantics.
+                    # Outcome: ordinary and required-positive NOT queries use both
+                    # GIN indexes; only genuinely unindexable negation scans the project.
+                    from_clause = """
+                            search_index JOIN (
+                                SELECT
+                                    candidate_parent.project_id,
+                                    candidate_parent.id,
+                                    candidate_parent.type
+                                FROM search_index AS candidate_parent
+                                WHERE candidate_parent.project_id = :project_id
+                                  AND querytree(to_tsquery('english', :text)) <> 'T'
+                                  AND candidate_parent.textsearchable_index_col
+                                      @@ to_tsquery('english', :text_candidate)
+                                UNION
+                                SELECT
+                                    candidate_chunk.project_id,
+                                    candidate_chunk.search_index_id AS id,
+                                    candidate_chunk.search_index_type AS type
+                                FROM search_index_fts_chunks AS candidate_chunk
+                                WHERE candidate_chunk.project_id = :project_id
+                                  AND querytree(to_tsquery('english', :text)) <> 'T'
+                                  AND candidate_chunk.textsearchable_index_col
+                                      @@ to_tsquery('english', :text_candidate)
+                                UNION
+                                SELECT
+                                    candidate_all.project_id,
+                                    candidate_all.id,
+                                    candidate_all.type
+                                FROM search_index AS candidate_all
+                                WHERE candidate_all.project_id = :project_id
+                                  AND querytree(to_tsquery('english', :text)) = 'T'
+                            ) AS fts_candidate
+                              ON fts_candidate.project_id = search_index.project_id
+                             AND fts_candidate.id = search_index.id
+                             AND fts_candidate.type = search_index.type
+                    """
+                document_vector_sql = self._document_fts_vector_sql(probe_texts, params)
+                conditions.append(f"{document_vector_sql} @@ to_tsquery('english', :text)")
 
         # Handle title search
         if title:
@@ -785,7 +966,7 @@ class PostgresSearchRepository(SearchRepositoryBase):
         # path parts instead of #>> / #> with interpolated paths.
         if metadata_filters:
             parsed_filters = parse_metadata_filters(metadata_filters)
-            from_clause = "search_index JOIN entity ON search_index.entity_id = entity.id"
+            from_clause = f"{from_clause} JOIN entity ON search_index.entity_id = entity.id"
             metadata_expr = "entity.entity_metadata::jsonb"
 
             for idx, filt in enumerate(parsed_filters):
@@ -863,14 +1044,59 @@ class PostgresSearchRepository(SearchRepositoryBase):
         # Build SQL with ts_rank() for scoring
         # Note: If no text search, score will be NULL, so we use COALESCE to default to 0
         if search_text and search_text.strip() and search_text.strip() != "*":
+            assert document_vector_sql is not None
             score_expr = (
-                "ts_rank(search_index.textsearchable_index_col, to_tsquery('english', :text))"
+                "GREATEST("
+                f"ts_rank({document_vector_sql}, to_tsquery('english', :text)), "
+                "ts_rank(search_index.textsearchable_index_col, to_tsquery('english', :text)), "
+                "COALESCE((SELECT MAX(ts_rank("
+                "fts_chunk.textsearchable_index_col, to_tsquery('english', :text))) "
+                "FROM search_index_fts_chunks AS fts_chunk "
+                "WHERE fts_chunk.project_id = search_index.project_id "
+                "AND fts_chunk.search_index_id = search_index.id "
+                "AND fts_chunk.search_index_type = search_index.type "
+                "AND fts_chunk.textsearchable_index_col "
+                "@@ to_tsquery('english', :text)), 0))"
             )
         else:
             score_expr = "0"
 
         return from_clause, where_clause, params, order_by_clause, score_expr
 
+    @staticmethod
+    def _document_fts_vector_sql(processed_texts: Sequence[str], params: dict[str, Any]) -> str:
+        """Build a query-sized vector representing lexemes found anywhere in one item."""
+        operands: dict[str, str] = {}
+        for processed_text in processed_texts:
+            for operand, representative in _tsquery_operands(processed_text):
+                operands.setdefault(operand, representative)
+
+        present_lexemes: list[str] = []
+        for index, (operand, representative) in enumerate(operands.items()):
+            operand_param = f"text_operand_{index}"
+            representative_param = f"text_representative_{index}"
+            params[operand_param] = operand
+            params[representative_param] = representative
+            present_lexemes.append(
+                "CASE WHEN (search_index.textsearchable_index_col "
+                f"@@ to_tsquery('english', :{operand_param}) OR EXISTS ("
+                "SELECT 1 FROM search_index_fts_chunks AS operand_chunk "
+                "WHERE operand_chunk.project_id = search_index.project_id "
+                "AND operand_chunk.search_index_id = search_index.id "
+                "AND operand_chunk.search_index_type = search_index.type "
+                "AND operand_chunk.textsearchable_index_col "
+                f"@@ to_tsquery('english', :{operand_param}))) "
+                f"THEN :{representative_param} ELSE '' END"
+            )
+
+        if not present_lexemes:
+            return "search_index.textsearchable_index_col"
+
+        # The synthesized text contains at most the query operands, never the note body.
+        # This preserves document-wide Boolean semantics without recreating an unbounded vector.
+        lexeme_array = f"ARRAY[{', '.join(present_lexemes)}]"
+        return f"to_tsvector('english', array_to_string({lexeme_array}, ' '))"
+
     @override
     async def search(
         self,
@@ -930,6 +1156,7 @@ class PostgresSearchRepository(SearchRepositoryBase):
             search_item_types=search_item_types,
             categories=categories,
             metadata_filters=metadata_filters,
+            allow_relaxed=allow_relaxed,
         )
 
         # set limit and offset
@@ -1111,6 +1338,7 @@ class PostgresSearchRepository(SearchRepositoryBase):
             search_item_types=search_item_types,
             categories=categories,
             metadata_filters=metadata_filters,
+            allow_relaxed=allow_relaxed,
         )
         sql = f"SELECT COUNT(*) FROM {from_clause} WHERE {where_clause}"
         logger.trace(f"Count {sql} params: {params}")

{basic_memory-0.23.1.dev2.dist-info → basic_memory-0.23.1.dev20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: basic-memory
-Version: 0.23.1.dev2
+Version: 0.23.1.dev20
 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

{basic_memory-0.23.1.dev2.dist-info → basic_memory-0.23.1.dev20.dist-info}/RECORD

@@ -23,6 +23,7 @@ basic_memory/alembic/versions/502b60eaa905_remove_required_from_entity_permalink
 basic_memory/alembic/versions/5fe1ab1ccebe_add_projects_table.py,sha256=xTSVvB-caYl_CdVfzhj-eqdQEOxQ12NIHOc8dBSqCMQ,4779
 basic_memory/alembic/versions/647e7a75e2cd_project_constraint_fix.py,sha256=oFtjzJd37HUMezuCUonK-yRc867_9L5zxd4CnLhFIi4,4655
 basic_memory/alembic/versions/6830751f5fb6_merge_multiple_heads.py,sha256=8bO4yg_v6klCJz0E15sDI2pDtsmAL2nNO5ACpKGLYQo,499
+basic_memory/alembic/versions/7f6a2b8c9d10_index_full_postgres_note_content.py,sha256=Kf4-_uBKe28MbpbKPsxZEKQzCYpIxv79iWxbKUZI91w,2857
 basic_memory/alembic/versions/9d9c1cb7d8f5_add_mtime_and_size_columns_to_entity_.py,sha256=DYlXlRYO3Ms6x9GbrFGWgj1QEzsdKHx-4AA4lSVM7y0,1587
 basic_memory/alembic/versions/a1b2c3d4e5f6_fix_project_foreign_keys.py,sha256=i42eQyO08RWf4exnH1q1PKw_EJFsHAG-T4pdLTMSpiA,1818
 basic_memory/alembic/versions/a2b3c4d5e6f7_add_search_index_entity_cascade.py,sha256=Oh_J5Jw85J3LvknfizFP7_1SoelZM_A7IjBau8lRpfk,1671
@@ -67,7 +68,7 @@ basic_memory/cli/__init__.py,sha256=arcKLAWRDhPD7x5t80MlviZeYzwHZ0GZigyy3NKVoGk,
 basic_memory/cli/analytics.py,sha256=GlyEFzvTRh2A8E1iFzRVLYVMn1_torhcbptfKNYU59w,3858
 basic_memory/cli/app.py,sha256=Tsz6bcWDWJWDBqdPnvEOQrUWG2UcdWriradzWj04r50,6318
 basic_memory/cli/auth.py,sha256=tQSE3uHhGPTfxkCcJ1FR2HDkmyu_E9uoaxHUENFUhAA,11523
-basic_memory/cli/auto_update.py,sha256=S48DmIcVSpaSCO70KriJ6jHQql5wLZewqame7RiBbgs,18060
+basic_memory/cli/auto_update.py,sha256=tYgJ8wjIuEwHGg4lh3UwMjFTija6_58GHAjJl1YeHr4,19690
 basic_memory/cli/container.py,sha256=5oIdLTEBsVNl_3q1blh50TSThCO_tEpDaO-cXITeQnk,2299
 basic_memory/cli/main.py,sha256=LF5u9iyvGDnn8DsfORzQOWVXFR0-TL2HHqntB2b8MFI,1160
 basic_memory/cli/promo.py,sha256=c_CxzCifl_1ZHPT7-Kd84TLG1Gt7sfXXmCmRYSTCerM,4592
@@ -76,7 +77,7 @@ basic_memory/cli/commands/ci.py,sha256=MW4pepm9472iMzbryA4p-r-SG-OPnFftshB-0S8LB
 basic_memory/cli/commands/command_utils.py,sha256=9_xUeeg1-nsnUw3MdNXOc_rhVROqhXqEDcTD3E_ga3A,5008
 basic_memory/cli/commands/config.py,sha256=8IBqPrcgklhvHkVFG8v9laO0PqZkvfLsZ_jgbPkFCb4,8700
 basic_memory/cli/commands/db.py,sha256=aQcjHpff15pfpDTKKpV-zz38TIJNfkOFQsCWggqbbU8,22596
-basic_memory/cli/commands/doctor.py,sha256=83KDPyNpMC4uuVR--5RPNtDl0H3tW6M-wciYCCAvMDQ,9963
+basic_memory/cli/commands/doctor.py,sha256=84AifKWTxcCibUOkZvJQ8P7PKuPK_P36KLy5d6aNvsQ,10755
 basic_memory/cli/commands/format.py,sha256=pgXkk0ptU2quN0XzjURuapA5AqrIBu1y4j6J1t52ovI,6753
 basic_memory/cli/commands/hook.py,sha256=tNtGzf4E40bhZQL6-SJwQpq8ehQmxm7EIae7O7-3jJg,60641
 basic_memory/cli/commands/import_chatgpt.py,sha256=7SUGG_mmme0BuL4ov0lhb98VkTUldunCv-ehQirtwZE,3870
@@ -92,7 +93,7 @@ basic_memory/cli/commands/routing.py,sha256=jGI7Sx0_E_M1sLqMjY3lFSE_uNEzKDhj-DkI
 basic_memory/cli/commands/schema.py,sha256=zGCrCM-PwWdZSVxD2_BF3dV_gdjtqp-qKFWVoitLAys,14260
 basic_memory/cli/commands/status.py,sha256=u0nLbQPJAhGAtJzkQY6iVw6qDzGJL2Sv9V5osmliYzk,7345
 basic_memory/cli/commands/tool.py,sha256=4q-WmCU6SftT3J_DkFH--dOLYmiCXd8k0_n-OhrRBNw,63870
-basic_memory/cli/commands/update.py,sha256=ah_Igpz4MiP53HKp7J1AEkjTcM_fjmJ6TIKrps4XNTk,1324
+basic_memory/cli/commands/update.py,sha256=ncOWOkk4AXvpLdJP-SQslIIPaybDoF02DMDnqkfcteE,1417
 basic_memory/cli/commands/workspace.py,sha256=ZpP-AicC4RJNCsDl5gSxJBDZVmcn0Q9TBtFsGOdeVNk,1043
 basic_memory/cli/commands/cloud/__init__.py,sha256=tHu2fkrQ0EHN3uFz4lSxpt0Msa7aJgAXQnZ3m-nRC74,1005
 basic_memory/cli/commands/cloud/api_client.py,sha256=CeL0n1hwISh6eNvMsfwc5GJ02TVlpysSYbqcDfIEU2k,5092
@@ -206,7 +207,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=PaeSERjUtxpAcMfV0QH63IUKeaPaFszTNbJYydYyils,12249
+basic_memory/markdown/plugins.py,sha256=y_gfzywOC4r-WNTYPPnn-Px0eiCTwdm2MJnFXJEfIwg,12831
 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
@@ -255,7 +256,7 @@ basic_memory/mcp/tools/ui_sdk.py,sha256=bVkNJUk0hH6j3q47wVZYbGMe4Xxe0UwrGvbCMC0p
 basic_memory/mcp/tools/utils.py,sha256=qMjO7UpCfGf5r3XsCCpelB-MPwSn8eGegLrh5SgEP08,31924
 basic_memory/mcp/tools/view_note.py,sha256=PtW_qIKYa1cu0W7Y-DlQYHcIx6M1FqWxMSH9pSpZHKU,2846
 basic_memory/mcp/tools/workspaces.py,sha256=m2G0vdYt2l084JtXq_t9a9V3_n6HnoT8MNSOvdclrXU,2826
-basic_memory/mcp/tools/write_note.py,sha256=emT91s9zMXRqM51y3j5laEYb1xyKoILjHBkzD-exyWw,19349
+basic_memory/mcp/tools/write_note.py,sha256=hbshPb59bKw1_JoTJtOgJl13wIbhXa80xwNn0Luyq2o,19529
 basic_memory/mcp/ui/__init__.py,sha256=shSaivFGUaKaK7rUt3NNja8tGPbi1Bqie1uTC7FzVCU,193
 basic_memory/mcp/ui/sdk.py,sha256=Vk23Cf4C_lA6BA2p21plE-Ia0r2-vpT6vw65D7swm-w,1764
 basic_memory/mcp/ui/templates.py,sha256=eUrtb3p90dhZusu6b5EjasxXpcn0NsQDbRNiufQcegQ,822
@@ -270,7 +271,7 @@ basic_memory/models/base.py,sha256=2F45uI2-_xyEaHDeqifEHSTsiwIbDcwE50QjQcuggMI,2
 basic_memory/models/knowledge.py,sha256=2D0aPlsgnjn5phWdAq-I4gMvn8chewIC1VzYLRgKQTM,16102
 basic_memory/models/project.py,sha256=8IMKWA_Z7mecAzRByRGi7V1XQ1XaYL8r_K9k91pdS6Q,3418
 basic_memory/models/relation_search_refresh.py,sha256=DA1v-N6G9nKJ7a-DvfSi13pGRdckNUfh_d9tiEvLqNY,1606
-basic_memory/models/search.py,sha256=82VYMaXPIm0muatYOXsBNVUGzveNNsdRUbWyifVbTIg,5818
+basic_memory/models/search.py,sha256=beMfq6vtdSXLuYTsjZUEBP6x-e7QU2qN-fHTUFxEmzM,6833
 basic_memory/picoschema/__init__.py,sha256=OsFNpVzzm38Y_0ELoTM_EcyGlnA1-_1DVx0ZKl45xNw,1270
 basic_memory/picoschema/diff.py,sha256=xjCzbS4XzrW6lXKjsGPSitMWDd3fbFrsA2JW9CslBtk,4212
 basic_memory/picoschema/inference.py,sha256=Cc02myST0zqmDKw0IUYjaPom8WrQFVvqrBbyurN4O5k,10575
@@ -306,7 +307,7 @@ basic_memory/repository/note_file_vacate_repository.py,sha256=3dyYc2ySkPJFEDMdH-
 basic_memory/repository/observation_repository.py,sha256=mLvIhjM3pbORBNUF-YT9NiPleUHgPCHNAjdNoFXEJaE,5710
 basic_memory/repository/openai_provider.py,sha256=kfGEqQYhi0dtOP91Ud9M9ARITz8ZKjpVJoPeRvQdLBc,4838
 basic_memory/repository/pgvector_index.py,sha256=Vh16pPMAo4SeLpd_g4FIfdO4VdR5FLnYYBlMcg0B3Xg,16119
-basic_memory/repository/postgres_search_repository.py,sha256=CUj8LqzzSwue-6Je-DjowJzJXMKAa1BM5KptfK3tetQ,50819
+basic_memory/repository/postgres_search_repository.py,sha256=6ySkknt5hOSGdNvblEGLqnEgxehQHliombcvhrvDEAg,62331
 basic_memory/repository/prefixing_provider.py,sha256=8qGzW3_9Y40O794vk0QkR6MUxN07ZHVj0awf0WEObAI,3312
 basic_memory/repository/project_info_repository.py,sha256=jr32DLlVWq8tmXOi7xALv1CxHlg9n6y5xlrz74G_CyM,317
 basic_memory/repository/project_repository.py,sha256=ZzpAynhh9vgaJdZjTsWGjBPvPjyfzPOX1AWiGlsdh-c,12592
@@ -390,8 +391,8 @@ basic_memory/services/search_service.py,sha256=OcT2wMn7rN1GQ_0l8OH8KKcoTG4D7-Evf
 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.1.dev2.dist-info/METADATA,sha256=NOQMQs1G7r47EKTCAEXUwwiwd-1il_7SJJFDi_P910k,26847
-basic_memory-0.23.1.dev2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-basic_memory-0.23.1.dev2.dist-info/entry_points.txt,sha256=wvE2mRF6-Pg4weIYcfQ-86NOLZD4WJg7F7TIsRVFLb8,90
-basic_memory-0.23.1.dev2.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-basic_memory-0.23.1.dev2.dist-info/RECORD,,
+basic_memory-0.23.1.dev20.dist-info/METADATA,sha256=kS21fqv6k0zvFoXQ3KaKUgv6UWpoDs_APp8C7FjTpqs,26848
+basic_memory-0.23.1.dev20.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+basic_memory-0.23.1.dev20.dist-info/entry_points.txt,sha256=wvE2mRF6-Pg4weIYcfQ-86NOLZD4WJg7F7TIsRVFLb8,90
+basic_memory-0.23.1.dev20.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+basic_memory-0.23.1.dev20.dist-info/RECORD,,