ccc search --path crashes the daemon: unsupported operand type(s) for *: 'NoneType' and 'NoneType'

[jaimebelt]

Package: cocoindex-code v0.2.39 (installed via pipx)

Summary
Any ccc search invocation that includes --path crashes the daemon with a TypeError surfaced as a RuntimeError: Daemon error: .... --lang alone works fine; adding --path (with or without --lang) reliably reproduces the crash.

Steps to reproduce

ccc search --lang python --path 'src/*' "example query text"
Observed error

RuntimeError: Daemon error: unsupported operand type(s) for *: 'NoneType' and 'NoneType'
Full traceback points through cli.py:675 → cli.py:284 (_search_with_wait_spinner) → client.py:422 (search), which just re-raises whatever error message the daemon sent back.

Root cause
In cocoindex_code/query.py, query_codebase() dispatches to _full_scan_query() whenever paths is provided:

def _full_scan_query(conn, embedding_bytes, limit, offset, languages=None, paths=None):
...
return conn.execute(
f"""
SELECT file_path, language, content, start_line, end_line,
vec_distance_L2(embedding, ?) as distance
FROM code_chunks_vec
{where}
ORDER BY distance
LIMIT ? OFFSET ?
""",
params,
).fetchall()
This reads the embedding column directly from the code_chunks_vec vec0 virtual table in a full scan combined with a WHERE clause (language/path filters), rather than using the MATCH ... k = ? KNN access pattern that _knn_query() uses. In this access pattern, vec_distance_L2(embedding, ?) returns NULL for every row (verified by running the exact SQL by hand against the generated target_sqlite.db — the raw embedding column reads fine in isolation, but vec_distance_L2 returns None once combined with the WHERE filter in this scan shape).

That None distance then flows into:

def _l2_to_score(distance: float) -> float:
return 1.0 - distance * distance / 2.0
None * None → the exact crash observed.

Expected behavior
ccc search --path '' should return path-filtered results, same as it does for --lang.

Actual behavior
Any use of --path crashes the daemon, regardless of query content or --lang combination.

Suggested fix direction
vec0 virtual tables generally only support reliable distance computation through the MATCH KNN query path, not through direct scalar-function calls against the raw column in an arbitrary full scan. _full_scan_query likely needs to either compute embeddings/distance outside the vec0 table (e.g., store/query embeddings via a shadow table it can full-scan safely), or restructure the path-filtered query to still go through a MATCH-based KNN query and post-filter by path in Python.

Note: Bug explored, reproduced and reported by Claude code

[georgeh0]

Thanks for the detailed report — the crash you hit is real, but I could not reproduce it, and I think the diagnosis in the "Root cause" section is off. Some findings below. The short version: please upgrade to v0.2.41 and re-run the failing command — it won't necessarily fix the crash, but it will report exactly where the failure happens.

vec_distance_L2 cannot return NULL

It raises on bad input rather than returning NULL, in every case:

vec_distance_L2(NULL, ?)  -> Error reading 1st vector: Input must have type BLOB (compact format) or TEXT (JSON), found NULL
wrong dimension           -> Vector dimension mistmatch. First vector has 4 dimensions, while the second has 3
zero-length blob          -> Error reading 2nd vector: zero-length vectors are not supported

This matches sqlite-vec's source. In vec0Column_fullscan, vector columns explicitly do return their blob during a full scan (vec0_get_vector_data → sqlite3_result_blob). The only thing that returns NULL there is the hidden distance column:

else if (i == vec0_column_distance_idx(pVtab)) {
    sqlite3_result_null(context);
}

So _full_scan_query either produces a real distance or raises — it can't silently yield None.

Couldn't reproduce it either

Using the exact DDL the indexer generates (id INTEGER primary key, +file_path, language partition key, +content, +start_line, +end_line, embedding float[384]), I ran the --path query across:

• sqlite-vec 0.1.6, 0.1.7, 0.1.8, 0.1.9 (0.1.0–0.1.5 predate + auxiliary columns)
• SQLite 3.46.0 and 3.53.1
• 500 / 3000 / 5000 rows (enough to span multiple vec0 chunks)
• after 30 simulated incremental re-index cycles (delete + reinsert churn)
• --path alone, and --lang + --path together

Zero NULL distances in every combination. ccc search --path 'src/*' against a real index also works here, and the e2e suite covers --path.

One thing worth ruling out: the search query code is byte-identical between the 0.2.39 and 0.2.40 releases, so this isn't something a 0.2.40 upgrade would have fixed.

Where a NULL distance can come from

Exactly one shape produces it — selecting the bare distance column under a full-scan plan:

KNN     : [('src/f1.py', 0.0), ('src/f2.py', 1.0), ('src/f0.py', 1.0)]
FULLSCAN: [('src/f0.py', None), ('src/f1.py', None), ('src/f2.py', None)]

That's _knn_query's shape, not _full_scan_query's. Which suggests the real failure may be a KNN query whose embedding MATCH ? AND k = ? wasn't picked up by vec0's xBestIndex, silently degrading to a full scan. That fits the symptom exactly — it just doesn't obviously fit a --path-only trigger, which is why I'd rather not guess at a fix.

Diagnostics fixed in v0.2.41

Two things made this much harder to diagnose than it should have been, both fixed in #271 and released in v0.2.41:

• The daemon's search handler discarded the traceback (ErrorResponse(message=str(e))), which is why your report has only the client's re-raise frames. It now sends the daemon-side traceback and logs the exception, and the client surfaces it on every request type.
• A KNN query that comes back with NULL distances now raises a specific error naming the query shape and the offending file, instead of dying as TypeError: unsupported operand type(s) for *.

The most useful thing you can do: upgrade and re-run

pipx upgrade cocoindex-code

Make sure you land on 0.2.41 (ccc version), then re-run the exact failing command. Instead of the bare TypeError, you should get either the full daemon-side traceback or the new NULL-distance error naming the query shape — please paste whichever appears. That output alone will likely pinpoint the real failure.

And a few details about your environment

1. Versions:

   python -c "import sqlite3, sqlite_vec, sys; print(sys.version); print('sqlite', sqlite3.sqlite_version); print('sqlite_vec', sqlite_vec.__version__ if hasattr(sqlite_vec,'__version__') else 'n/a')"
   

2. Output of ccc doctor, and your embedding provider/model from ~/.cocoindex_code/global_settings.yml.
3. Whether --lang python alone genuinely still returns results on the same index (just to confirm the KNN path is healthy).
4. Against your target_sqlite.db, the output of:

   SELECT sql FROM sqlite_master WHERE name = 'code_chunks_vec';
   SELECT COUNT(*), COUNT(vec_length(embedding)) FROM code_chunks_vec;

5. Whether the index predates any ccc upgrade — and whether ccc reset + re-index makes it go away. If it does, that points at the on-disk index rather than the query.

[jaimebelt]

Thanks for the quick turnaround. Upgraded and re-ran — here's everything requested.

Version

Already on 0.2.41 (pipx upgrade cocoindex-code reported "already at latest version 0.2.41").

Re-running the exact failing command

ccc search --lang php --path 'swyft-backend/*' "seeder month year date format questionnaire field"

The traceback fix (#271) worked — I now get the full daemon-side traceback instead of the bare client re-raise. However, it's still the same TypeError, not the new NULL-distance error:

╭────────────────────────────────────────────────────────────────────────────────────────────── Traceback (most recent call last) ───────────────────────────────────────────────────────────────────────────────────────────────╮
│ /Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/cli.py:147 in wrapper                                                                                                                │
│                                                                                                                                                                                                                                │
│    144 │   │   from .client import DaemonStartError                                                                                                                                                                            │
│    145 │   │                                                                                                                                                                                                                   │
│    146 │   │   try:                                                                                                                                                                                                            │
│ ❱  147 │   │   │   return func(*args, **kwargs)                                                                                                                                                                                │
│    148 │   │   except DaemonStartError as e:                                                                                                                                                                                   │
│    149 │   │   │   _typer.echo(f"Error: {e}", err=True)                                                                                                                                                                        │
│    150 │   │   │   raise _typer.Exit(code=1)                                                                                                                                                                                   │
│                                                                                                                                                                                                                                │
│ /Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/cli.py:685 in search                                                                                                                 │
│                                                                                                                                                                                                                                │
│    682 │   │   if default is not None:                                                                                                                                                                                         │
│    683 │   │   │   paths = [default]                                                                                                                                                                                           │
│    684 │                                                                                                                                                                                                                       │
│ ❱  685 │   resp = _search_with_wait_spinner(                                                                                                                                                                                   │
│    686 │   │   project_root=project_root,                                                                                                                                                                                      │
│    687 │   │   query=query_str,                                                                                                                                                                                                │
│    688 │   │   languages=lang or None,                                                                                                                                                                                         │
│                                                                                                                                                                                                                                │
│ /Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/cli.py:294 in _search_with_wait_spinner                                                                                              │
│                                                                                                                                                                                                                                │
│    291 │   │   │   │   refresh=True,                                                                                                                                                                                           │
│    292 │   │   │   )                                                                                                                                                                                                           │
│    293 │   │                                                                                                                                                                                                                   │
│ ❱  294 │   │   resp = _client.search(                                                                                                                                                                                          │
│    295 │   │   │   project_root=project_root,                                                                                                                                                                                  │
│    296 │   │   │   query=query,                                                                                                                                                                                                │
│    297 │   │   │   languages=languages,                                                                                                                                                                                        │
│                                                                                                                                                                                                                                │
│ /Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/client.py:435 in search                                                                                                              │
│                                                                                                                                                                                                                                │
│   432 │   │   │   │   raise RuntimeError("Connection to daemon lost during search")                                                                                                                                            │
│   433 │   │   │   resp = decode_response(data)                                                                                                                                                                                 │
│   434 │   │   │   if isinstance(resp, ErrorResponse):                                                                                                                                                                          │
│ ❱ 435 │   │   │   │   raise _daemon_error(resp)                                                                                                                                                                                │
│   436 │   │   │   if isinstance(resp, IndexWaitingNotice):                                                                                                                                                                     │
│   437 │   │   │   │   if on_waiting is not None:                                                                                                                                                                               │
│   438 │   │   │   │   │   on_waiting()                                                                                                                                                                                         │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
RuntimeError: Daemon error: unsupported operand type(s) for *: 'NoneType' and 'NoneType'
Traceback (most recent call last):
  File "/Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/daemon.py", line 544, in _dispatch
    results = await project.search(
              ^^^^^^^^^^^^^^^^^^^^^
    ...<5 lines>...
    )
    ^
  File "/Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/project.py", line 206, in search
    results = await query_codebase(
              ^^^^^^^^^^^^^^^^^^^^^
    ...<7 lines>...
    )
    ^
  File "/Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/query.py", line 177, in query_codebase
    score=_l2_to_score(distance),
          ~~~~~~~~~~~~^^^^^^^^^^
  File "/Users/howdy/.local/pipx/venvs/cocoindex-code/lib/python3.14/site-packages/cocoindex_code/query.py", line 16, in _l2_to_score
    return 1.0 - distance * distance / 2.0
                 ~~~~~~~~~^~~~~~~~~~
TypeError: unsupported operand type(s) for *: 'NoneType' and 'NoneType'

So it looks like the new "NULL distance with a named query shape" error only covers the KNN (_knn_query) path — the full-scan path taken whenever --path is passed (_full_scan_query in query.py) still hits the raw _l2_to_score(None) crash rather than the new named error. Might be worth extending that same guard to the full-scan branch.

Environment

3.14.5 (main, May 10 2026, 10:21:34) [Clang 21.0.0 (clang-2100.0.123.102)]
sqlite 3.53.2
sqlite_vec 0.1.9

~/.cocoindex_code/global_settings.yml embedding config:

embedding:
  provider: sentence-transformers
  model: nomic-ai/CodeRankEmbed
  device: mps
  query_params:
    prompt_name: query

ccc doctor (trimmed to the relevant parts)

Daemon
  Version: 0.2.41
  [OK] Model Check (indexing) — embedding dimension: 768
  [OK] Model Check (query) — embedding dimension: 768

Project Settings
  [OK] File Walk — ~8.7k files matched
  [OK] Index Status
    Chunks: 108875
    Files: 8584

No errors/warnings anywhere in doctor output.

--lang alone, same index — confirmed healthy

ccc search --lang python "example query text"

Returns real, relevant results with no error. Only adding --path triggers the crash — with or without --lang alongside it.

Direct SQL against target_sqlite.db

Schema:

CREATE VIRTUAL TABLE "code_chunks_vec" USING vec0(
    id INTEGER primary key,
    +file_path TEXT,
    language TEXT partition key,
    +content TEXT,
    +start_line INTEGER,
    +end_line INTEGER,
    embedding float[768]
)

Row/embedding count check:

SELECT COUNT(*), COUNT(vec_length(embedding)) FROM code_chunks_vec;
-- (108875, 108875)

Every row has a non-null, full-length embedding — so this isn't a missing/corrupt-embedding issue on my index.

I then ran the exact query shape _full_scan_query builds, by hand, against this same (non-reset) index:

SELECT file_path, language, vec_distance_L2(embedding, ?) as distance
FROM code_chunks_vec
WHERE language IN ('python') AND (file_path GLOB 'src/*')
ORDER BY distance
LIMIT 5 OFFSET 0;

distance comes back NULL for every single row, even though a plain SELECT embedding FROM code_chunks_vec LIMIT 1 (no WHERE, no distance function) returns a real embedding blob. So it reproduces with 100% consistency purely from the query shape — a WHERE-filtered scan calling vec_distance_L2 directly against the vec0 virtual table's embedding column, outside the MATCH ... k = ? KNN pattern, yields NULL distances regardless of the underlying data.

Re-index

Given the count check above (108875/108875 non-null embeddings, no doctor warnings) I don't think this is a stale-index issue — the embeddings are all present and readable in isolation, the failure is 100% reproducible purely by the query shape (WHERE-filtered scan + vec_distance_L2 vs. MATCH-based KNN). Happy to run ccc reset && ccc index and re-test if you still want that data point, but I'd guess it won't change the outcome given the above.

Let me know if there's anything else useful I can pull.