basic-memory 0.23.3.dev2__tar.gz → 0.23.3.dev4__tar.gz

{basic_memory-0.23.3.dev2 → basic_memory-0.23.3.dev4}/CONTRIBUTING.md

@@ -99,19 +99,33 @@ This project is designed for collaborative development between humans and LLMs (
 
 ## Pull Request Process
 
-1. **Create a Pull Request**: Open a PR against the `main` branch with a clear title and description.
+1. **Create a Pull Request**: Open a PR against the `main` branch with a clear title and description. PR titles must
+   follow the semantic format `type(scope): summary`, enforced by CI — for example `fix(core): unresolve inbound
+   relations on entity delete`. Allowed types: `feat`, `fix`, `chore`, `docs`, `style`, `refactor`, `perf`, `test`,
+   `build`, `ci`. Allowed scopes: `core`, `cli`, `api`, `mcp`, `sync`, `ui`, `ci`, `deps`, `installer`, `plugins`,
+   `skills`, `integrations`.
 2. **Sign the Developer Certificate of Origin (DCO)**: All commits require a `Signed-off-by` line certifying that you
    have the right to submit your contributions. The DCO status check verifies this automatically when you create a PR.
+   See [Signing Your Commits](#signing-your-commits) below, including how to fix commits you already pushed.
 3. **Accept the Contributor License Agreement (CLA)**: All contributors must also accept the
    [Contributor License Agreement](CLA.md). The `license/cla` status check verifies this separately from the DCO check.
+   There is no separate step outside GitHub: when you open your first PR, the CLA assistant bot comments with a link
+   (also at [cla-assistant.io/basicmachines-co/basic-memory](https://cla-assistant.io/basicmachines-co/basic-memory)).
+   Sign in with your GitHub account, agree, and the check turns green on its own. You sign once per GitHub account;
+   it covers your future PRs too.
 4. **PR Description**: Include:
     - What the PR changes
     - Why the change is needed
     - How you tested the changes
     - Any related issues (use "Fixes #123" to automatically close issues)
 5. **Code Review**: Wait for code review and address any feedback.
-6. **CI Checks**: Ensure all CI checks pass.
-7. **Merge**: Once approved, a maintainer will merge your PR.
+6. **CI Checks**: Ensure all CI checks pass. Note that the test matrix runs only on pushes to this repository, so a PR
+   from a fork gets the DCO, CLA, and static checks but not the full test suite. Run `just test` locally before
+   asking for review.
+7. **Merge**: Once approved, a maintainer will merge your PR. For fork PRs, a maintainer usually cherry-picks your
+   commits onto an in-repo branch so the full matrix can run, opens a replacement PR that references yours, and
+   rebase-merges it. Your commits land on `main` with your authorship and sign-off intact; the original PR is closed
+   with a link to the replacement.
 
 ## Developer Certificate of Origin and CLA
 
@@ -136,7 +150,17 @@ Sign your commit:
 git commit -s -m "Your commit message"
 ```
 
-This adds a `Signed-off-by` line to your commit message, certifying that you adhere to the DCO.
+This adds a `Signed-off-by: Your Name <you@example.com>` line to your commit message, certifying that you adhere to
+the DCO. The name and email must match the commit's author (`git config user.name` / `user.email`), or the DCO check
+fails.
+
+If you already made commits without a sign-off, add it retroactively and force-push your branch:
+
+```bash
+# Sign off every commit on your branch (all commits since main)
+git rebase --signoff origin/main
+git push --force-with-lease
+```
 
 The sign-off certifies that you have the right to submit your contribution under the project's license and verifies your
 agreement to the DCO.

{basic_memory-0.23.3.dev2 → basic_memory-0.23.3.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: basic-memory
-Version: 0.23.3.dev2
+Version: 0.23.3.dev4
 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.3.dev2 → basic_memory-0.23.3.dev4}/src/basic_memory/indexing/batch_indexer.py

@@ -159,11 +159,14 @@ class BatchIndexer:
         *,
         max_concurrent: int,
         parse_max_concurrent: int | None = None,
+        metadata_update_max_concurrent: int | None = None,
         existing_permalink_by_path: dict[str, str | None] | None = None,
     ) -> IndexingBatchResult:
         """Index one batch of loaded files with bounded concurrency."""
         if max_concurrent <= 0:
             raise ValueError("max_concurrent must be greater than zero")
+        if metadata_update_max_concurrent is not None and metadata_update_max_concurrent <= 0:
+            raise ValueError("metadata_update_max_concurrent must be greater than zero")
 
         ordered_paths = sorted(files)
         if not ordered_paths:
@@ -220,7 +223,11 @@ class BatchIndexer:
 
         refreshed, refresh_errors = await self._run_bounded(
             [path for path in ordered_paths if path in prepared_entities],
-            limit=self.app_config.index_metadata_update_max_concurrent,
+            limit=(
+                self.app_config.index_metadata_update_max_concurrent
+                if metadata_update_max_concurrent is None
+                else metadata_update_max_concurrent
+            ),
             worker=lambda path: self._refresh_search_index(
                 prepared_entities[path],
                 entities_by_id[prepared_entities[path].entity_id],

{basic_memory-0.23.3.dev2 → basic_memory-0.23.3.dev4}/src/basic_memory/indexing/index_batch_runtime.py

@@ -56,6 +56,7 @@ class IndexInputBatchExecutor(Protocol):
         *,
         max_concurrent: int,
         parse_max_concurrent: int | None = None,
+        metadata_update_max_concurrent: int | None = None,
     ) -> IndexingBatchResult:
         """Index one batch of storage-neutral input files."""
 
@@ -105,6 +106,7 @@ class IndexBatchRuntime[EntityT: IndexedNoteContentEntity, FileInfoT: LoadedInde
             input_files,
             max_concurrent=max_concurrent,
             parse_max_concurrent=parse_max_concurrent,
+            metadata_update_max_concurrent=metadata_update_max_concurrent,
         )
         reconciliation = await reconcile_indexed_note_content_batch(
             result.indexed,

{basic_memory-0.23.3.dev2 → basic_memory-0.23.3.dev4}/tests/indexing/test_batch_indexer.py

@@ -192,6 +192,58 @@ async def test_batch_indexer_parses_markdown_with_parallel_path(
     assert result.errors == []
 
 
+@pytest.mark.asyncio
+async def test_batch_indexer_honors_explicit_search_refresh_concurrency(
+    app_config,
+    entity_service,
+    entity_repository,
+    relation_repository,
+    search_service,
+    file_service,
+    project_config,
+    monkeypatch,
+):
+    paths = ("notes/one.md", "notes/two.md")
+    for path in paths:
+        await _create_file(project_config.home / path, f"# {Path(path).stem}\n")
+
+    files = {path: await _load_input(file_service, path) for path in paths}
+    batch_indexer = _make_batch_indexer(
+        app_config,
+        entity_service,
+        entity_repository,
+        relation_repository,
+        search_service,
+        file_service,
+    )
+    original_index_entity_data = search_service.index_entity_data
+    in_flight = 0
+    max_in_flight = 0
+
+    async def spy_index_entity_data(*args, **kwargs):
+        nonlocal in_flight, max_in_flight
+        in_flight += 1
+        max_in_flight = max(max_in_flight, in_flight)
+        await asyncio.sleep(0.05)
+        try:
+            return await original_index_entity_data(*args, **kwargs)
+        finally:
+            in_flight -= 1
+
+    monkeypatch.setattr(search_service, "index_entity_data", spy_index_entity_data)
+
+    result = await batch_indexer.index_files(
+        files,
+        max_concurrent=2,
+        parse_max_concurrent=2,
+        metadata_update_max_concurrent=1,
+    )
+
+    assert result.errors == []
+    assert len(result.indexed) == 2
+    assert max_in_flight == 1
+
+
 @pytest.mark.asyncio
 async def test_batch_indexer_creates_entities_with_real_db_session(
     app_config,

{basic_memory-0.23.3.dev2 → basic_memory-0.23.3.dev4}/tests/indexing/test_index_batch_runtime.py

@@ -90,6 +90,7 @@ class RecordingBatchIndexer:
     calls: list[dict[str, IndexInputFile]] = field(default_factory=list)
     max_concurrent: int | None = None
     parse_max_concurrent: int | None = None
+    metadata_update_max_concurrent: int | None = None
     published_generation_by_entity_id: dict[int, int] | None = None
     publish_max_concurrent: int | None = None
 
@@ -99,10 +100,12 @@ class RecordingBatchIndexer:
         *,
         max_concurrent: int,
         parse_max_concurrent: int | None = None,
+        metadata_update_max_concurrent: int | None = None,
     ) -> IndexingBatchResult:
         self.calls.append(dict(files))
         self.max_concurrent = max_concurrent
         self.parse_max_concurrent = parse_max_concurrent
+        self.metadata_update_max_concurrent = metadata_update_max_concurrent
         return self.result
 
     async def publish_relation_generations(
@@ -258,6 +261,7 @@ async def test_index_batch_runtime_indexes_loaded_files_and_reconciles_note_cont
 
     assert batch_indexer.max_concurrent == 4
     assert batch_indexer.parse_max_concurrent == 2
+    assert batch_indexer.metadata_update_max_concurrent == 1
     assert batch_indexer.calls[0]["ok.md"] == IndexInputFile(
         path="ok.md",
         size=5,