claude-code-conductor 2.27.0__tar.gz → 2.28.0__tar.gz

{claude_code_conductor-2.27.0 → claude_code_conductor-2.28.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [2.28.0] - 2026-05-27
+
+**recall 増分 rebuild**: `c3 recall rebuild` を全再構築から増分に最適化。未変更チャンクは既存インデックスのベクトルを再利用し、変更/新規チャンクのみ再埋め込みする。律速の埋め込み（fastembed 推論）を削減して rebuild を高速化する。検索結果・インデックス形式は全再構築と一致。**破壊的変更なし**。
+
+### 機能追加
+
+- **`src/c3/cli_recall.py`: `c3 recall rebuild` の増分化**: `(source_type, path, chunk_id)` と `source_hash`（v2 で既に保存済み）が一致する未変更チャンクは旧ベクトルを再利用し、変更/新規チャンクのみ `embed_passages` に渡す。出力は `embedded M / reused K chunks` 形式。`--force` 指定時は従来どおり全再構築。
+- **`src/c3/recall_index.py`: `RecallIndex.get_vector(chunk_id)` / 公開 `content_hash(text)` を追加**: `get_vector` は hnswlib 格納ベクトルを取得（増分時の再利用に使用）。`content_hash` は source_hash 計算を一元化した公開ヘルパー（`build` と `cli_recall` が共用）。
+
+### 変更
+
+- **増分不可時の安全フォールバック**: 既存インデックス不在・`--force`・`load()` 失敗（model/dim 不一致・破損）の場合は全再構築にフォールバックし、stderr に理由（例外型名のみ）を 1 行出力する。
+
+### 後方互換
+
+- 検索結果・インデックス形式は全再構築と完全一致（増分はベクトル再利用のみで意味論を変えない）。
+- `--force` で従来の全再構築を維持。
+- migration 不要。**破壊的変更なし**。
+
 ## [2.27.0] - 2026-05-26
 
 **tier-routing λ 機能拡張（CR-Q-001 精緻化・λ 上限 5.0・cli_tier routing パラメータ表示）**: v2.26.0 で繰り越した 3 項目を解消。λ の上限を 1.0 から 5.0 に拡張、cost-aware tie-break の observability フラグを精緻化、`c3 tier stats` に現在の routing パラメータ（λ/ε/escalation）を表示。環境変数未設定時の routing 出力は v2.26.0 と一致。**破壊的変更なし**。

{claude_code_conductor-2.27.0 → claude_code_conductor-2.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 2.27.0
+Version: 2.28.0
 Summary: Multi-agent orchestration framework for Claude Code with Codex/Cursor adapters (C3)
 Project-URL: Homepage, https://github.com/satoh-y-0323/claude-code-conductor
 Project-URL: Repository, https://github.com/satoh-y-0323/claude-code-conductor

{claude_code_conductor-2.27.0 → claude_code_conductor-2.28.0}/src/c3/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Conductor (C3) - multi-agent orchestration framework for Claude Code."""
 
-__version__ = "2.27.0"
+__version__ = "2.28.0"

{claude_code_conductor-2.27.0 → claude_code_conductor-2.28.0}/src/c3/cli_recall.py

@@ -14,7 +14,6 @@ fast even when the embedding model has not yet been downloaded.
 from __future__ import annotations
 
 import argparse
-import hashlib
 import json
 import sys
 from pathlib import Path
@@ -30,6 +29,7 @@ from c3.recall_index import (
     RecallIndex,
     SourceChunk,
     collect_sources,
+    content_hash,
     default_index_paths,
     snippet_of,
     warn_if_stale,
@@ -200,6 +200,58 @@ def _handle_search(args: argparse.Namespace) -> int:
     return 0
 
 
+def _partition_chunks_for_reuse(
+    chunks: list[SourceChunk],
+    old_index: RecallIndex,
+) -> tuple[list[int], dict[int, list[float]], int]:
+    """Partition *chunks* into embed targets and reusable vectors from *old_index*.
+
+    Returns a triple ``(to_embed_indices, reuse_map, reused_count)`` where:
+
+    - ``to_embed_indices``: positions in *chunks* that need fresh embedding
+      (new or content-changed chunks).
+    - ``reuse_map``: ``{chunk_position: vector}`` for unchanged chunks whose
+      vector was successfully retrieved from *old_index*.
+    - ``reused_count``: number of chunks successfully reused.
+
+    The caller is responsible for embedding ``to_embed_indices`` and then
+    assembling the final ``items`` list in original *chunks* order to keep
+    ``build()`` ID assignment consistent with a full rebuild.
+    """
+    # Build a lookup: (source_type, path, chunk_id) -> (source_hash, int_id)
+    old_key_map: dict[tuple[str, str, str], tuple[str, int]] = {}
+    for id_str, rec in old_index.meta.chunks.items():
+        key = (rec.source_type, rec.path, rec.chunk_id)
+        old_key_map[key] = (rec.source_hash, int(id_str))
+
+    # Partition chunks into those that need embedding and those that can be reused.
+    # We fill reuse_map for unchanged slots so the final items list preserves the
+    # original order — this ensures build() assigns sequential IDs identically to
+    # a full rebuild (same order → same IDs → same search results).
+    to_embed_indices: list[int] = []  # indices into chunks that need embedding
+    reuse_map: dict[int, list[float]] = {}  # chunk index → reused vector
+    reused_count = 0
+
+    for i, src in enumerate(chunks):
+        key = (src.source_type, src.path, src.chunk_id)
+        new_hash = content_hash(src.content)
+        if key in old_key_map:
+            old_hash, old_id = old_key_map[key]
+            if old_hash == new_hash:
+                # Unchanged: reuse the stored vector.
+                try:
+                    vec = old_index.get_vector(old_id)
+                    reuse_map[i] = vec
+                    reused_count += 1
+                    continue
+                except Exception:
+                    pass  # Vector retrieval failed; fall through to embed
+        # New or changed chunk: needs embedding.
+        to_embed_indices.append(i)
+
+    return to_embed_indices, reuse_map, reused_count
+
+
 def _handle_rebuild(args: argparse.Namespace) -> int:
     repo_root = _resolve_repo_root(getattr(args, "target", None))
     if repo_root is None:
@@ -225,27 +277,98 @@ def _handle_rebuild(args: argparse.Namespace) -> int:
         )
         return 1
 
-    print(f"[recall] embedding {len(chunks)} chunks...")
-    vectors = embedder.embed_passages([c.content for c in chunks]) if chunks else []
+    index_path, meta_path = default_index_paths(repo_root)
+
+    # ----- incremental path -----
+    # Attempt to load the existing index and reuse vectors for unchanged chunks.
+    # Falls back to full embed when:
+    #   - --force is requested
+    #   - no existing index files
+    #   - load() raises RuntimeError (model/dim mismatch or corrupt meta)
+    #   - any other unexpected error during load
+
+    old_index: RecallIndex | None = None
+    if not args.force and index_path.exists() and meta_path.exists():
+        candidate = RecallIndex(
+            index_path=index_path,
+            meta_path=meta_path,
+            model_name=embedder.model_name,
+            dim=embedder.dim,
+        )
+        try:
+            candidate.load()
+            old_index = candidate
+        except Exception as exc:
+            # CR-E-002/SR-R-004: log the failure reason so operators can diagnose
+            # corrupt or mismatched index files. Exception message is intentionally
+            # omitted (type name only) to avoid leaking internal state — consistent
+            # with the SR-R-001 policy used in _hnsw_save/_hnsw_load.
+            print(
+                f"[recall] 既存 index を読めず増分不可・全再構築にフォールバック: {type(exc).__name__}",
+                file=sys.stderr,
+            )
+            old_index = None
+
     items: list[tuple[ChunkRecord, list[float]]] = []
-    for src, vec in zip(chunks, vectors):
-        # CR-M-04 / SR-L-5: compute source_hash from the full content so that
-        # identical chunks in different files produce the same hash and changed
-        # content is reliably detected across rebuilds.
-        content_hash = hashlib.sha256(
-            src.content.encode("utf-8", errors="replace")
-        ).hexdigest()
-        record = ChunkRecord(
-            source_type=src.source_type,
-            path=src.path,
-            chunk_id=src.chunk_id,
-            snippet=snippet_of(src.content),
-            mtime=src.mtime,
-            source_hash=content_hash,
+
+    if old_index is not None:
+        to_embed_indices, reuse_map, reused_count = _partition_chunks_for_reuse(
+            chunks, old_index
         )
-        items.append((record, vec))
 
-    index_path, meta_path = default_index_paths(repo_root)
+        # Embed only the changed/new chunks.
+        embed_count = len(to_embed_indices)
+        to_embed_contents = [chunks[i].content for i in to_embed_indices]
+        if to_embed_contents:
+            new_vectors = embedder.embed_passages(to_embed_contents)
+        else:
+            new_vectors = []
+
+        # i is always present in embed_vec_map because it was added to
+        # to_embed_indices during _partition_chunks_for_reuse — every chunk
+        # not in reuse_map is guaranteed to have an entry here.
+        embed_vec_map: dict[int, list[float]] = {
+            idx: vec for idx, vec in zip(to_embed_indices, new_vectors)
+        }
+
+        # Build items in original chunks order to preserve ID assignment consistency.
+        for i, src in enumerate(chunks):
+            if i in reuse_map:
+                vec = reuse_map[i]
+            else:
+                # Invariant: i is in to_embed_indices, so it is always present in
+                # embed_vec_map. Every chunk not placed in reuse_map during
+                # _partition_chunks_for_reuse was added to to_embed_indices and
+                # therefore has a corresponding entry in embed_vec_map.
+                vec = embed_vec_map[i]
+            record = ChunkRecord(
+                source_type=src.source_type,
+                path=src.path,
+                chunk_id=src.chunk_id,
+                snippet=snippet_of(src.content),
+                mtime=src.mtime,
+                source_hash=content_hash(src.content),
+            )
+            items.append((record, vec))
+
+        print(f"[recall] embedded {embed_count} / reused {reused_count} chunks")
+    else:
+        # Full embed path (--force, no prior index, or load failure).
+        print(f"[recall] embedding {len(chunks)} chunks...")
+        vectors = embedder.embed_passages([c.content for c in chunks]) if chunks else []
+        for src, vec in zip(chunks, vectors):
+            # CR-M-04 / SR-L-5: compute source_hash from the full content so that
+            # identical chunks in different files produce the same hash and changed
+            # content is reliably detected across rebuilds.
+            record = ChunkRecord(
+                source_type=src.source_type,
+                path=src.path,
+                chunk_id=src.chunk_id,
+                snippet=snippet_of(src.content),
+                mtime=src.mtime,
+                source_hash=content_hash(src.content),
+            )
+            items.append((record, vec))
 
     if args.force:
         for p in (index_path, meta_path):

{claude_code_conductor-2.27.0 → claude_code_conductor-2.28.0}/src/c3/recall_index.py

@@ -159,9 +159,7 @@ class RecallIndex:
             # If the caller already computed a hash (e.g. from full content),
             # keep it; otherwise derive from the stored snippet as a fallback.
             if not record.source_hash:
-                record.source_hash = hashlib.sha256(
-                    record.snippet.encode("utf-8", errors="replace")
-                ).hexdigest()
+                record.source_hash = content_hash(record.snippet)
             self._meta.chunks[str(new_id)] = record
         self._index.add_items(vecs, ids)
         self._meta.rebuilt_at = _utcnow_iso()
@@ -293,6 +291,22 @@ class RecallIndex:
     def chunk_count(self) -> int:
         return len(self._meta.chunks)
 
+    def get_vector(self, chunk_id: int) -> list[float]:
+        """Return the stored vector for ``chunk_id`` as ``list[float]``.
+
+        Raises ``RuntimeError`` if the index has not been built or loaded yet.
+        Propagates hnswlib's exception (typically ``RuntimeError`` or
+        ``IndexError``) when ``chunk_id`` is not present in the index.
+        """
+        if self._index is None:
+            raise RuntimeError(
+                "index has not been built or loaded; call build() or load() first"
+            )
+        # hnswlib.get_items returns a 2-D array of shape (n, dim).
+        # We pass a single-element list and take the first row.
+        result = self._index.get_items([chunk_id])
+        return [float(x) for x in result[0]]
+
     # ----- internals -----
 
     def _new_index(self, *, max_elements: int):
@@ -475,6 +489,17 @@ def is_stale(repo_root: Path, index_path: Path) -> bool:
 # ----- helpers -----
 
 
+def content_hash(text: str) -> str:
+    """Return the SHA-256 hex digest of *text* encoded as UTF-8.
+
+    ``errors="replace"`` ensures arbitrary Unicode input never raises.
+    This is the canonical hash used for incremental-rebuild change detection
+    (``cli_recall._handle_rebuild``) and as the ``source_hash`` fallback in
+    :meth:`RecallIndex.build`.
+    """
+    return hashlib.sha256(text.encode("utf-8", errors="replace")).hexdigest()
+
+
 def snippet_of(text: str, *, max_chars: int = SNIPPET_CHARS) -> str:
     """Return a stable preview of ``text`` for storage / display."""
     text = (text or "").strip()

{claude_code_conductor-2.27.0 → claude_code_conductor-2.28.0}/tests/hooks/test_session_start.py

@@ -161,7 +161,14 @@ class TestClearFileHistory:
         assert not sub.exists()
 
     def test_symlink_uses_unlink_not_rmtree(self, tmp_path: Path):
-        """シンボリックリンクは os.unlink で削除（TOCTOU 対策）."""
+        """シンボリックリンクは os.unlink で除去し shutil.rmtree には渡さない（TOCTOU 対策）。
+
+        OS 非依存にするため削除ルーティングを spy で検証する。リンク先 dir も
+        file-history 直下にあるため別エントリとして rmtree される（=消えるのが正しい）。
+        旧実装の ``target_dir.exists()`` assertion は「リンク先も直下エントリ」である点を
+        見落としており、symlink を作れない Windows では skip され露呈しなかった
+        （Linux CI で顕在化）。
+        """
         module = _load_hook_module()
         fake_history = tmp_path / "file-history"
         fake_history.mkdir()
@@ -173,12 +180,17 @@ class TestClearFileHistory:
         except OSError:
             pytest.skip("シンボリックリンクを作れない環境（権限不足等）")
 
-        with patch.object(module, "FILE_HISTORY_DIR", str(fake_history)):
+        with patch.object(module, "FILE_HISTORY_DIR", str(fake_history)), \
+             patch.object(module.os, "unlink", wraps=module.os.unlink) as unlink_spy, \
+             patch.object(module.shutil, "rmtree", wraps=module.shutil.rmtree) as rmtree_spy:
             module._run_clear_file_history()
 
-        # symlink 自体は消えるが、リンク先は消えない
+        # symlink 自体は unlink で除去され、rmtree には渡らない
         assert not symlink.exists()
-        assert target_dir.exists()
+        unlinked = [call.args[0] for call in unlink_spy.call_args_list]
+        rmtree_targets = [call.args[0] for call in rmtree_spy.call_args_list]
+        assert str(symlink) in unlinked
+        assert str(symlink) not in rmtree_targets
 
     def test_external_symlink_is_skipped(self, tmp_path: Path):
         """リンク先が FILE_HISTORY_DIR 外のシンボリックリンクはスキップする."""

{claude_code_conductor-2.27.0 → claude_code_conductor-2.28.0}/tests/test_cli_init.py

@@ -3,8 +3,11 @@
 from __future__ import annotations
 
 import argparse
+import os
 from pathlib import Path
 
+import pytest
+
 from c3 import cli_init, cli_update
 
 
@@ -181,6 +184,13 @@ def test_init_codex_refuses_unmanaged_existing_c3_mcp_table(tmp_path: Path, caps
     assert "already defines [mcp_servers.c3]" in capsys.readouterr().err
 
 
+@pytest.mark.skipif(
+    os.sep != "\\",
+    reason=(
+        "config の PYTHONPATH バックスラッシュエスケープは Windows パスでのみ発生する"
+        "（escape ロジック自体は tests/test_adapters.py で OS 非依存に検証済み）"
+    ),
+)
 def test_update_codex_preserves_escaped_backslashes_in_managed_config(tmp_path: Path):
     _run_init(tmp_path, platform="codex")
     config = tmp_path / ".codex" / "config.toml"