codecortex 0.24.0__tar.gz → 0.24.1__tar.gz

{codecortex-0.24.0/src/codecortex.egg-info → codecortex-0.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.24.0
+Version: 0.24.1
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

{codecortex-0.24.0 → codecortex-0.24.1/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.24.0
+Version: 0.24.1
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT

codecortex-0.24.1/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.24.1"

{codecortex-0.24.0 → codecortex-0.24.1}/src/codeintel/commands/index.py

@@ -6,6 +6,11 @@ from typing import Any
 
 from codeintel.commands._common import resolve_root
 
+# How long a foreground `codeintel index` waits for another process's pass over the same repository
+# before indexing anyway. Long enough to outlast a cold index of a large repo (measured at ~10 min
+# for 30k chunks, docs/benchmarks.md); short enough that a hung holder cannot block it forever.
+_LOCK_WAIT_S = 900.0
+
 
 class _ProgressLogBridge(logging.Handler):
     """Routes WARNING+ log records from the indexer to a live progress counter's ``notice()``, so a
@@ -52,6 +57,35 @@ def run(args: Any) -> int:
     quiet = getattr(args, "quiet", False)
     counter = None if quiet else term.LiveCounter(console)
 
+    # Take the same per-repository lock the background reindexer takes, so a terminal `index` and
+    # a running server's background pass do not embed the whole repository twice. It covers the
+    # semantic AND graph passes, as the background pass does; the map refresh is not indexing.
+    import contextlib
+
+    from codeintel.filelock import exclusive_waiting, lock_path
+
+    def _say_waiting() -> None:
+        if not quiet:       # --quiet promises the result line only, contention or not
+            print("waiting for another codeintel process to finish indexing this repository…",
+                  flush=True)
+
+    lock = contextlib.ExitStack()
+    # Resolving the lock path reads the codeintel home, which raises where there is no resolvable
+    # home directory (a container UID with no passwd entry and no CODEINTEL_HOME). That must not
+    # turn into a traceback before the semantic pass's own error handling below — which reports
+    # exactly that failure as "index failed: …". A lock we cannot place is a lock we do without,
+    # by the rule in `filelock`: it may dedupe work, never stop it.
+    try:
+        path = lock_path(os.path.realpath(project_root))
+    except Exception:
+        path = None
+    if path is not None:
+        got_lock = lock.enter_context(
+            exclusive_waiting(path, _LOCK_WAIT_S, on_wait=_say_waiting))
+        if not got_lock and not quiet:
+            print(f"still locked after {int(_LOCK_WAIT_S)}s — indexing anyway; the other pass "
+                  "may repeat some of this work", flush=True)
+
     failed = False
     # Wrap the whole semantic pass so a setup failure (e.g. an unresolvable home dir →
     # Path.home() raising) degrades with a message, like every other subcommand, not a traceback.
@@ -146,6 +180,8 @@ def run(args: Any) -> int:
             if beat:
                 beat.stop("warn", "skipped")
 
+    lock.close()
+
     # best-effort map refresh after index (fast, kept silent — not worth a checklist row)
     try:
         from codeintel.mapper import MapGenerator

{codecortex-0.24.0 → codecortex-0.24.1}/src/codeintel/filelock.py

@@ -33,7 +33,8 @@ import logging
 import os
 import pathlib
 import re
-from collections.abc import Iterator
+import time
+from collections.abc import Callable, Iterator
 
 logger = logging.getLogger(__name__)
 
@@ -99,6 +100,45 @@ def exclusive(path: pathlib.Path) -> Iterator[bool]:
             os.close(fd)                # closing would release it anyway; explicit is clearer
 
 
+@contextlib.contextmanager
+def exclusive_waiting(
+    path: pathlib.Path,
+    timeout_s: float,
+    *,
+    poll_s: float = 0.25,
+    on_wait: Callable[[], None] | None = None,
+) -> Iterator[bool]:
+    """Like `exclusive`, but WAIT up to *timeout_s* for another holder to finish.
+
+    For work a person asked for. A background pass that loses the race skips, because nobody asked
+    for it and the holder is already doing it. A foreground `codeintel index` cannot skip: the user
+    asked for an index, and "somebody else is probably doing it" is not one. So it waits, and once
+    the holder finishes, its own pass is incremental and mostly finds nothing new.
+
+    Yields True once the lock is held, and False when *timeout_s* passed with it still held — in
+    which case the caller proceeds WITHOUT the lock, by the module's rule that a lock may dedupe work
+    but never stop it. A holder that is alive but hung must not block indexing forever.
+
+    *on_wait* runs once, the first time the lock is found held, so a caller can say why it has
+    stopped moving. Without `fcntl` there is nothing to wait on and this yields True at once.
+    """
+    deadline = time.monotonic() + max(0.0, timeout_s)
+    announced = False
+    while True:
+        with exclusive(path) as got:
+            if got:
+                yield True
+                return
+        if not announced and on_wait is not None:
+            announced = True
+            with contextlib.suppress(Exception):
+                on_wait()
+        if time.monotonic() >= deadline:
+            yield False
+            return
+        time.sleep(poll_s)
+
+
 def held_by_another_process(path: pathlib.Path) -> bool:
     """True when some other live process holds this lock.
 

{codecortex-0.24.0 → codecortex-0.24.1}/tests/test_bench_corpus_typed.py

@@ -144,3 +144,23 @@ def test_the_typed_arm_scores_only_the_class_qualified_targets():
             f"{target} does not look class-qualified; this arm scores only that shape"
         )
         assert os.path.exists(os.path.join(_TYPED, path)), path
+
+
+def test_both_corpora_give_serena_the_same_project_config():
+    """The serena config is part of what the language server sees, so it is part of the control.
+
+    It also stops the churn this repository kept seeing. A newer serena upgrades every REGISTERED
+    project's `project.yml` to its current template when it starts — and codeintel launching serena
+    with `--project <fixture>` registers the fixtures. `corpus_ts_typed` was generated by that
+    newer serena and never drifted; `corpus_ts` held an older template and was rewritten at the
+    start of every session. Keeping the two identical (apart from the name) keeps them both on the
+    template the other one already proved stable, and makes a future re-template show up here as
+    one file differing from its twin rather than as an unexplained diff."""
+    def config(root: str, name: str) -> str:
+        with open(os.path.join(root, ".serena", "project.yml"), encoding="utf-8") as fh:
+            text = fh.read()
+        assert f'project_name: "{name}"' in text, f"{root}: project_name is not {name!r}"
+        return text.replace(f'project_name: "{name}"', 'project_name: "<name>"')
+
+    assert config(_TYPED, "corpus_ts_typed") == config(_UNTYPED, "corpus_ts"), (
+        "the two fixtures' .serena/project.yml differ beyond project_name — copy one over the other")

{codecortex-0.24.0 → codecortex-0.24.1}/tests/test_cli_commands.py

@@ -12,6 +12,7 @@ commands, or a command dispatches to nothing.
 from __future__ import annotations
 
 import argparse
+import os
 import string
 import subprocess
 import sys
@@ -930,3 +931,92 @@ def test_query_json_stays_parseable_when_the_query_itself_fails(monkeypatch, cap
     payload = _json.loads(capsys.readouterr().out)      # must not raise
     assert payload["result"] is None
     assert "backend exploded" in payload["reason"]
+
+
+# --------------------------------------------------------------------------- index lock
+
+def test_index_holds_the_reindex_lock_for_its_whole_pass(monkeypatch, tmp_path):
+    """A server's background reindex skips while this is held, so the repository is embedded once.
+    Checked from inside the pass, because holding it "somewhere around" the pass is not enough."""
+    from codeintel.filelock import _HAVE_FLOCK, held_by_another_process, lock_path
+    if not _HAVE_FLOCK:
+        pytest.skip("advisory locking needs POSIX fcntl")
+    seen = _stub_index(monkeypatch, tmp_path, count=1, has_graph_backend=True)
+    path = lock_path(os.path.realpath(str(tmp_path)))
+    held: dict[str, bool] = {}
+
+    import codeintel.indexer as indexer_mod
+    base = indexer_mod.Indexer
+
+    class _Checking(base):  # type: ignore[misc, valid-type]
+        def index(self, root):
+            held["semantic"] = held_by_another_process(path)
+            return super().index(root)
+
+    monkeypatch.setattr("codeintel.indexer.Indexer", _Checking)
+    import codeintel.reindexer as reindexer_mod
+    graph_base = reindexer_mod.Reindexer
+
+    class _CheckingGraph(graph_base):  # type: ignore[misc, valid-type]
+        def _graph_reindex(self, root):
+            held["graph"] = held_by_another_process(path)
+            super()._graph_reindex(root)
+
+    monkeypatch.setattr("codeintel.reindexer.Reindexer", _CheckingGraph)
+
+    assert import_module("codeintel.commands.index").run(_args(project_root=str(tmp_path))) == 0
+    assert held == {"semantic": True, "graph": True}, held
+    assert seen["reindexed"]
+    assert not held_by_another_process(path), "the lock outlived the command"
+
+
+def test_index_waits_for_another_pass_then_indexes_anyway_on_timeout(monkeypatch, tmp_path, capsys):
+    """Held by someone else: say so, wait, and — past the limit — index anyway. Never skip: the
+    user asked for an index, and a hung holder must not be able to stop one."""
+    from codeintel.filelock import _HAVE_FLOCK, exclusive, lock_path
+    if not _HAVE_FLOCK:
+        pytest.skip("advisory locking needs POSIX fcntl")
+    _stub_index(monkeypatch, tmp_path, count=7)
+    mod = import_module("codeintel.commands.index")
+    monkeypatch.setattr(mod, "_LOCK_WAIT_S", 0.3)
+
+    with exclusive(lock_path(os.path.realpath(str(tmp_path)))) as other:
+        assert other
+        assert mod.run(_args(project_root=str(tmp_path))) == 0
+
+    out = capsys.readouterr().out
+    assert "waiting for another codeintel process" in out
+    assert "indexing anyway" in out
+    assert "Indexed 7 chunks" in out
+
+
+def test_index_quiet_stays_quiet_while_waiting_for_the_lock(monkeypatch, tmp_path, capsys):
+    """`--quiet` promises the result line only. Contention is not an exception to that."""
+    from codeintel.filelock import _HAVE_FLOCK, exclusive, lock_path
+    if not _HAVE_FLOCK:
+        pytest.skip("advisory locking needs POSIX fcntl")
+    _stub_index(monkeypatch, tmp_path, count=2)
+    mod = import_module("codeintel.commands.index")
+    monkeypatch.setattr(mod, "_LOCK_WAIT_S", 0.2)
+
+    with exclusive(lock_path(os.path.realpath(str(tmp_path)))) as other:
+        assert other
+        assert mod.run(_args(project_root=str(tmp_path), quiet=True)) == 0
+
+    assert capsys.readouterr().out.strip() == "Indexed 2 chunks"
+
+
+def test_index_without_a_resolvable_home_fails_with_a_message_not_a_traceback(
+        monkeypatch, tmp_path, capsys):
+    """A container UID with no home: the lock is skipped, and the failure the semantic pass hits
+    is reported the way it always was — `index failed: …` and exit 1."""
+    _stub_index(monkeypatch, tmp_path)
+
+    def _no_home(*a, **k):
+        raise RuntimeError("could not determine home directory")
+
+    monkeypatch.setattr("codeintel.filelock.lock_path", _no_home)
+    monkeypatch.setattr("codeintel.config.load_config", _no_home)
+
+    assert import_module("codeintel.commands.index").run(_args(project_root=str(tmp_path))) == 1
+    assert "index failed: could not determine home directory" in capsys.readouterr().out

{codecortex-0.24.0 → codecortex-0.24.1}/tests/test_reindex_lock.py

@@ -25,10 +25,18 @@ import pathlib
 import subprocess
 import sys
 import textwrap
+import threading
+import time
 
 import pytest
 
-from codeintel.filelock import _HAVE_FLOCK, exclusive, held_by_another_process, lock_path
+from codeintel.filelock import (
+    _HAVE_FLOCK,
+    exclusive,
+    exclusive_waiting,
+    held_by_another_process,
+    lock_path,
+)
 from codeintel.reindexer import Reindexer
 
 pytestmark = pytest.mark.skipif(not _HAVE_FLOCK, reason="advisory locking needs POSIX fcntl")
@@ -207,3 +215,53 @@ def test_a_probe_that_fails_does_not_claim_a_reindex_is_running(home, monkeypatc
     monkeypatch.setattr(fl, "exclusive", lambda _p: (_ for _ in ()).throw(OSError("nope")))
 
     assert fl.held_by_another_process(path) is False
+
+
+# ══════════════════════════════════════════════════════════════════════════════════════════════
+# Waiting — for work a person asked for
+# ══════════════════════════════════════════════════════════════════════════════════════════════
+
+def test_a_free_lock_is_taken_at_once_without_announcing_a_wait(home):
+    waits: list[int] = []
+    with exclusive_waiting(lock_path("/repo/one"), 5, on_wait=lambda: waits.append(1)) as got:
+        assert got is True
+    assert waits == []
+
+
+def test_a_held_lock_is_waited_for_and_then_taken(home):
+    """The foreground case: another pass is running, so wait for it rather than skip or duplicate."""
+    path = lock_path("/repo/one")
+    waits: list[int] = []
+    holding, release = threading.Event(), threading.Event()
+
+    def holder() -> None:
+        with exclusive(path) as got:
+            assert got
+            holding.set()
+            release.wait(5)
+
+    t = threading.Thread(target=holder)
+    t.start()
+    holding.wait(5)
+    threading.Timer(0.4, release.set).start()
+
+    started = time.monotonic()
+    with exclusive_waiting(path, 10, poll_s=0.05, on_wait=lambda: waits.append(1)) as got:
+        waited = time.monotonic() - started
+        assert got is True
+        assert held_by_another_process(path), "yielded True without actually holding the lock"
+    t.join(5)
+
+    assert waits == [1], "the wait must be announced exactly once"
+    assert waited >= 0.3, f"took the lock after {waited:.2f}s while it was still held"
+
+
+def test_a_lock_held_past_the_timeout_yields_false_so_the_work_still_happens(home):
+    """A hung holder must not block indexing forever: time out, say so, proceed."""
+    path = lock_path("/repo/one")
+    waits: list[int] = []
+    with exclusive(path) as first:
+        assert first
+        with exclusive_waiting(path, 0.2, poll_s=0.05, on_wait=lambda: waits.append(1)) as got:
+            assert got is False
+    assert waits == [1]

codecortex-0.24.0/src/codeintel/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.24.0"