code-context-control 2.53.0__py3-none-any.whl → 2.54.0__py3-none-any.whl

cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.53.0"
+__version__ = "2.54.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -165,6 +165,7 @@ def _build_init_config(project_path: str) -> dict:
         "project_path": project_path,
         "version": __version__,
         "index_auto_update": True,
+        "index_max_files": 2000,
         "compression_mode": "smart",
         "mcp": {"mode": "direct"},
         "hybrid": deepcopy(HYBRID_DEFAULTS),
@@ -890,7 +891,7 @@ def _parse_cli_ide_arg(value: str) -> str:
     return normalized
 
 
-def _do_init(project_path: str, ide_name: str = None):
+def _do_init(project_path: str, ide_name: str = None, no_embed: bool = False):
     """Run the core init steps (shared by new install and re-init after clear/reset)."""
     config = _build_init_config(project_path)
     save_config(config, project_path)
@@ -898,10 +899,27 @@ def _do_init(project_path: str, ide_name: str = None):
     for subdir in _C3_INIT_SUBDIRS:
         (Path(project_path) / CONFIG_DIR / subdir).mkdir(parents=True, exist_ok=True)
 
+    import time as _t
+
+    from cli.progress import ProgressLine
+
     print("Building code index...")
+    _prog = ProgressLine()
+    _t0 = _t.perf_counter()
     indexer = CodeIndex(project_path)
-    result = indexer.build_index()
-    print(f"  Indexed {result['files_indexed']} files, {result['chunks_created']} chunks")
+    result = indexer.build_index(
+        on_progress=lambda entries, files, chunks: _prog.update(
+            f"  scanning: {entries:,} entries | {files:,} files | {chunks:,} chunks"))
+    _prog.done()
+    entries = result.get("entries_scanned", 0)
+    print(f"  Indexed {result['files_indexed']} files, {result['chunks_created']} chunks "
+          f"in {_t.perf_counter() - _t0:.1f}s ({entries:,} entries scanned)")
+    capped = result.get("files_capped", 0)
+    if capped:
+        total = result["files_indexed"] + capped
+        print(f"  [!] Indexed {result['files_indexed']} of {total} candidate files "
+              f"(cap: index_max_files={result.get('max_files')}).")
+        print("      Raise index_max_files in .c3/config.json for full coverage.")
 
     # Build embedding index if Ollama is available (non-blocking on failure)
     try:
@@ -912,13 +930,24 @@ def _do_init(project_path: str, ide_name: str = None):
         ollama = OllamaClient(ollama_url)
         embed_model = config.get("embed_model", "nomic-embed-text")
         ei = EmbeddingIndex(project_path, ollama, embed_model=embed_model)
-        if ei.ready:
+        if no_embed:
+            print("  Embedding index skipped (--no-embed)")
+        elif ei.probe()["ready"]:
+            # probe() initializes the lazy backends; checking .ready on a
+            # fresh instance is always False and silently skipped the build.
             print("Building embedding index...")
-            ei_result = ei.build(indexer)
+            _t0 = _t.perf_counter()
+            _eprog = ProgressLine()
+            ei_result = ei.build(
+                indexer,
+                on_progress=lambda done, total, chunks: _eprog.update(
+                    f"  embedding: file {done}/{total} | {chunks:,} chunks"))
+            _eprog.done()
             print(f"  Embedded {ei_result.get('chunks_embedded', 0)} chunks "
-                  f"({ei_result.get('files_processed', 0)} files)")
+                  f"({ei_result.get('files_processed', 0)} files) "
+                  f"in {_t.perf_counter() - _t0:.1f}s")
         else:
-            print("  Embedding index skipped (Ollama not available or model not pulled)")
+            print(f"  Embedding index skipped ({ei.unavailable_reason()})")
     except Exception:
         _log.debug("Embedding index build failed", exc_info=True)
 
@@ -926,15 +955,22 @@ def _do_init(project_path: str, ide_name: str = None):
     try:
         from services.doc_index import DocIndex
         print("Building doc index...")
+        _t0 = _t.perf_counter()
+        _dprog = ProgressLine()
         di = DocIndex(project_path)
-        di_result = di.build()
-        print(f"  Indexed {di_result['docs_indexed']} docs, {di_result['chunks_created']} chunks")
+        di_result = di.build(
+            on_progress=lambda done, total: _dprog.update(
+                f"  docs: {done}/{total}"))
+        _dprog.done()
+        print(f"  Indexed {di_result['docs_indexed']} docs, "
+              f"{di_result['chunks_created']} chunks in {_t.perf_counter() - _t0:.1f}s")
     except Exception:
         _log.debug("Doc index build failed", exc_info=True)
 
     print("Building compression dictionary...")
     protocol = CompressionProtocol(project_path)
-    new_terms = protocol.build_project_dictionary()
+    # Mine the in-memory index instead of re-reading the whole tree.
+    new_terms = protocol.build_project_dictionary(code_index=indexer)
     print(f"  Added {len(new_terms)} project-specific terms")
 
     from core.ide import detect_ide, load_ide_config
@@ -966,11 +1002,12 @@ def cmd_init(args):
     if requested_ide != "auto":
         requested_ide = normalize_ide_name(requested_ide)
     git_requested = getattr(args, "git", False)
+    no_embed = bool(getattr(args, "no_embed", False))
 
     # ── Brand-new install ──────────────────────────────────────
     if not c3_dir.exists() or not (c3_dir / "config.json").exists():
         print_header(f"Initializing C3 for: {project_path}")
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         try:
             from services.project_manager import ProjectManager
             ProjectManager().add_project(project_path)
@@ -1123,7 +1160,7 @@ def cmd_init(args):
         ti_manifest = c3_dir / "transcript_index" / "manifest.json"
         if ti_manifest.exists():
             ti_manifest.write_text("{}", encoding="utf-8")
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _run_install_mcp(project_path, requested_ide, mcp_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1152,7 +1189,7 @@ def cmd_init(args):
     # ── Non-interactive (--force) ──────────────────────────────
     if getattr(args, "force", False):
         print("\n[--force] Applying update...")
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _run_install_mcp(project_path, requested_ide, mcp_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1176,7 +1213,7 @@ def cmd_init(args):
 
     if selected.startswith("Update"):
         print()
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _prompt_install_mcp(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1192,7 +1229,7 @@ def cmd_init(args):
                 shutil.rmtree(target)
                 print(f"  Removed .c3/{subdir}/")
         print()
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _prompt_install_mcp(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1209,7 +1246,7 @@ def cmd_init(args):
         shutil.rmtree(c3_dir)
         print("  Deleted .c3/")
         print()
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _prompt_install_mcp(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"), banner="Re-installing MCP tools...")

cli/commands/parser.py

@@ -24,6 +24,7 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_init.add_argument("--ide", default="auto", type=parse_cli_ide_arg, metavar="{auto,claude,vscode,cursor,codex,antigravity}", help="Target IDE for MCP config (default: auto-detect)")
     p_init.add_argument("--mcp-mode", choices=["direct", "proxy"], default="direct", help="Default MCP mode if install is selected during init (default: direct)")
     p_init.add_argument("--git", action="store_true", help="Initialize a local Git repository during init/update")
+    p_init.add_argument("--no-embed", action="store_true", help="Skip building the semantic embedding index during init")
     p_init.add_argument("--permissions", choices=["read-only", "c3-strict", "standard", "permissive"], default=None, help="Apply Claude Code permission tier (Claude Code only, used with --force)")
     p_init.add_argument("--include-mcp-wildcard", action="store_true", help="Add mcp__* wildcard so non-C3 MCP servers don't prompt per-call")
 

cli/hub_server.py

@@ -1027,8 +1027,10 @@ def api_run_component():
             ollama = OllamaClient(ollama_url)
             embed_model = cfg.get("embed_model", "nomic-embed-text")
             ei = EmbeddingIndex(resolved, ollama, embed_model=embed_model)
-            if not ei.ready:
-                return jsonify({"success": True, "output": "Embedding index skipped (Ollama not available or model not pulled)."})
+            # probe() initializes lazy backends; a fresh instance's .ready
+            # is always False and would skip the build unconditionally.
+            if not ei.probe()["ready"]:
+                return jsonify({"success": True, "output": f"Embedding index skipped ({ei.unavailable_reason()})."})
             indexer = CodeIndex(resolved)
             if not indexer.chunks:
                 indexer._load_index()

cli/progress.py

@@ -0,0 +1,49 @@
+"""
+Single-line TTY progress for long CLI phases (index/embedding builds).
+
+Quiet when stdout is piped - CI logs and command substitutions see only
+the final summary lines, never carriage-return spam.
+"""
+import sys
+import time
+
+
+class ProgressLine:
+    """Rewrites one status line in place; time-throttled; TTY-only."""
+
+    def __init__(self, stream=None, min_interval: float = 0.1):
+        self.stream = stream if stream is not None else sys.stdout
+        self.min_interval = min_interval
+        self._last = 0.0
+        self._width = 0
+        try:
+            self._tty = bool(self.stream.isatty())
+        except Exception:
+            self._tty = False
+
+    def update(self, text: str) -> None:
+        if not self._tty:
+            return
+        now = time.monotonic()
+        if now - self._last < self.min_interval:
+            return
+        self._last = now
+        pad = ' ' * max(0, self._width - len(text))
+        try:
+            self.stream.write('\r' + text + pad)
+            self.stream.flush()
+        except Exception:
+            self._tty = False
+            return
+        self._width = len(text)
+
+    def done(self) -> None:
+        """Clear the in-place line so the following prints start clean."""
+        if not self._tty or not self._width:
+            return
+        try:
+            self.stream.write('\r' + ' ' * self._width + '\r')
+            self.stream.flush()
+        except Exception:
+            pass
+        self._width = 0

{code_context_control-2.53.0.dist-info → code_context_control-2.54.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.53.0
+Version: 2.54.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Copilot, Cursor, Antigravity). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP).
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.53.0.dist-info → code_context_control-2.54.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cli/__init__.py,sha256=ec66drCZGNMRU4V6ov0zVhYZph1us12Vn8OvG_LJyRY,22
 cli/_hook_utils.py,sha256=tJ4ZmXD5Y-JjFWb0uoR7ycYklYFUMnnjF2G7BO-wyBI,12600
-cli/c3.py,sha256=ziZSc1n6ksQL_asFvZ4ErsQbT29DMA-WYh324AwTOII,307360
+cli/c3.py,sha256=jTV4sTDaPkooaJtlwaQOAKYXY4Q6C5RfyioKX35vfTM,309220
 cli/docs.html,sha256=bNymSz7LatnWHjxSXL92QSUtGvB3jBzNHbOV-bRpAOo,142507
 cli/edits.html,sha256=UjAhoCmBmQ89cklGvJqzC6eyNP2tc8H6T-e01DVkLvE,43418
 cli/hook_artifact.py,sha256=Se1CNBfoBFyvJQlRmYdNtdRXIkQp9zaF0O6ndRMo7ts,2198
@@ -18,17 +18,18 @@ cli/hook_read.py,sha256=ZWZldgqGSNz78COhlgETQ7yxdOW5vWIIHUet9gZKhxk,8176
 cli/hook_session_stats.py,sha256=hZiX0r1SLOstu1PXvygWae0cIqHCcC3mb0SbFL6nCic,2083
 cli/hook_terse_advisor.py,sha256=W_zaTfX2akgX-ifuUTsLu2H1atM8XmWt6jpPoeU7Pm0,6252
 cli/hub.html,sha256=Hl-XPZGT1mMiKrbX9c5OsEw6mXEumwIB3vp1WlWaplM,183966
-cli/hub_server.py,sha256=fZUw32ZNUrQgB9Jo82JSfPmDq02kFOcOwxgbtXFgLq0,105299
+cli/hub_server.py,sha256=5y6jIs2qaz5HoBdLXBl2yPtqIZ2VM17rJ4bWUOfUcSs,105443
 cli/hub_ui.html,sha256=nnGqWhWGCLfNisGUnoAlQFcBr6wPNsq-AEOR7uFtVkE,2942
 cli/mcp_proxy.py,sha256=92htuT-p0j-cDTbyqlIJpGoQ85_Aw7UuB8L_Toi_u20,17511
 cli/mcp_server.py,sha256=YgzI2U1jW-ax9HCCVUwXeikMHDMlS4Qq-RdhnQuTvt4,40898
+cli/progress.py,sha256=qTkNy0howOD3hXraMo4ok3dYTpBW5yG_tenKfF4UDM0,1470
 cli/server.py,sha256=WOEPgptkJSVtS25IwrPdOMdbKOh79Sm6-vdQlTOk-sA,136012
 cli/ui.html,sha256=xcdt74nlFEXx-0Bx6-Okw-WSVZPAXL0iukxU0ytI6CA,5694
 cli/ui_legacy.html,sha256=cI8tC6RKmE2NIJOcsu7CY-zT4VznjcbD6NTjxb_fvUY,378460
 cli/ui_nano.html,sha256=UAwQ6bbTOXAoGq191AZ7slhngR9edJSa3IhqpynveDg,27740
 cli/commands/__init__.py,sha256=0Z8MABNzwSFJGT4Xv9R5AJVR8XxraTsuVTz5b0bShmo,38
 cli/commands/common.py,sha256=fHZWzkd4OLl3vPWTTgaI5vaqMi3Ma3XqAu1Ds_-51_4,11299
-cli/commands/parser.py,sha256=dutcYYE7qImgZ1ZouobTRe2TyUMHii_r56vyQA7UVOw,25489
+cli/commands/parser.py,sha256=0ym7T3xjsQPhj2jm0_aUHCQGx6Whcp1m50gH5JDSFHw,25611
 cli/guide/bitbucket.html,sha256=9vN1VPLmvTLrkqDSrqKmuy7z3BHEmQusY1jkAG0FjnI,33477
 cli/guide/getting-started.html,sha256=5iS-_iAP1PboU9pFbMsfh8C9Du9usqOfIyawOc-X4Hg,19070
 cli/guide/index.html,sha256=mUDUBX590TTappvrKT7_eXi0P8G-3YvHjGk9pCcwWzQ,21350
@@ -94,7 +95,7 @@ cli/ui/components/sessions.js,sha256=FIKtil76B8tCkAmcFV7hlj6GQ_DCJK2jCzvEmdK7NBE
 cli/ui/components/settings.js,sha256=ATbAjBlVIwCNpxq7s191b49a_INQV38iwmySqtJLYwY,79066
 cli/ui/components/sidebar.js,sha256=cAY_jwYB-o1X_wWn__VXlG4IegVObuE3NmVsuFWqxtg,7417
 cli/ui/components/tasks.js,sha256=vyKQ3uwoppMwvdEaHlhWXW4oWcAisx4NveqzMhsYqHo,38438
-code_context_control-2.53.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
+code_context_control-2.54.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
 core/__init__.py,sha256=TSDCEcM4V7gcZVM3w2ykJaqEUch4Dkon-rivV17T73s,2501
 core/config.py,sha256=NUU1DuespWRotlJsv59CNnLiWTR4Bc7ysmD1UFA76RE,16429
 core/ide.py,sha256=V6VVMVsFdmmcsMyxikjQp7z9xa42CWiHKS-ya-MAcG4,6172
@@ -152,20 +153,20 @@ services/bitbucket_client.py,sha256=JByovvtVZ6F4NcU611KVuTgKlT1rIsX2A2VlBDfvRV8,
 services/bitbucket_credentials.py,sha256=2qLA9pQMol4y95y4DJMNBsBBPUsJQCKbLFo2iiCnfvI,7364
 services/circuit_breaker.py,sha256=ES6PpjL40gfDhtK88GeS6GFzsz5EOEEkZsB-DzX_tbw,3179
 services/claude_md.py,sha256=vI2at-7DEsnRXYcSaE88uNTxCSxzhy8M77AM20VlYRc,42643
-services/compressor.py,sha256=urGF7CYv9BUWUhcf3tY64k-LCwE-LOq44BMl_NIMzU4,33337
+services/compressor.py,sha256=AK31TqHFpkOD_Lqbp9aEOkOx7zENUwpsQHQ9B2imEHo,33081
 services/context_snapshot.py,sha256=2f_bxY3xX4ZC653ncYno8YSeSTFSavwBjrorytHA0Ns,16879
 services/conversation_store.py,sha256=-E2H6f9pMSOHiBjsq7tFUjrFAwWYExf7LJkibi5MRMA,35650
-services/doc_index.py,sha256=LTMVFsxQY5pPynGuu787433xBKMhE8KYbOrbLHooZqs,19038
+services/doc_index.py,sha256=ZEQD1kyGCAMm9AY4Kpi1zDWJTul-cAcAdi_4Md43Hpw,19205
 services/e2e_benchmark.py,sha256=4pDXkOFjq5b2ZwDvMK0CWdUXQli5OE4cOh_OJs7W36c,132970
 services/e2e_evaluator.py,sha256=FsB4vMzcFUcmicfIwRtA8JZ_XeMpuk2_-86F2iVNEDc,17783
 services/e2e_tasks.py,sha256=Ln5VbGDIcS3NY3aml5ERbgjfjLxEslmRZ8AyaYxpWEo,34524
 services/edit_ledger.py,sha256=LbFDAnqAWKXsc5pUdJ8zSk5-1MNUwJduK3MO8_HUm5E,29018
-services/embedding_index.py,sha256=-ThnMbyMSnmMN0-iKCsMYn9hXTDlGbk7Cm75h5NMadc,14129
+services/embedding_index.py,sha256=WVAmQkpvwbu2GaQfg4iPWyWiW8zQNN0ldQAo9ibsyBc,15908
 services/error_reporting.py,sha256=HZ3ru8i5RLf8nq2R4iRnTs5sm1blUxknSbv5hdxuxs0,4139
 services/file_memory.py,sha256=ero1EY_42z0ORzZaOyvRK7Pc_OYxvgijf4BaKhEBPuY,34241
 services/git_context.py,sha256=FFdA8Y46op4DYsUnZsXLTqxIjgxb0q_d-hkFTbosC8Q,9518
 services/hub_service.py,sha256=Ta2ExJP1sePxb7zcHooroYXJKsylm5Ea8vQvts6-cAw,21876
-services/indexer.py,sha256=EIX7hu1x-hQIHiiUwG8R7bklZgWZu6BH5SuQsgvyyNs,27874
+services/indexer.py,sha256=00y47xufHFEotljPDH4RBbWcqAHmCpTouafiggGcP7I,29511
 services/memory.py,sha256=UxlZ3BwYfTlq6Rlj5RPhNOw42bds-dSe5KAdA4TXBLE,13150
 services/memory_consolidator.py,sha256=hHMps-01cbbHSI-A1LEKCo3k2PoLOa8a7-vyYEf8DUs,19679
 services/memory_distiller.py,sha256=-07rtR3XhiZqKCUCFOcuAktfTJIbtcNqMj7rM35WXKg,26081
@@ -182,16 +183,17 @@ services/output_filter.py,sha256=lknQHs38JlRtXU4Ogoru6sveNokSKBQPfZXhf-fE0xM,217
 services/parser.py,sha256=CPoIN1FmX7kK-55FnC3jvRy3NLjlnf1armTaD6o7GBg,55203
 services/project_manager.py,sha256=LaNWqBeVMx6wcB6iiOQyRWSWhS-JXzfDApJmHFmTCy8,36477
 services/project_runtime.py,sha256=yyftX48BFjq4B2KcR4KGszDAAa4xR6gn6j0SgTyro1s,11603
-services/protocol.py,sha256=E0xxs43j-YSOBWalKHbX_wwqphQgDjqUjyyvTW0s6II,12247
+services/protocol.py,sha256=XyUGjTHD9Zouw94IEqwH667pQ1TlroleLzlM3GRlEGk,12843
 services/proxy_state.py,sha256=u5rd0k6CrOsywZA8FpRu_hMLwhR0TAJhZjy5MdWbCGc,6107
 services/retention.py,sha256=I2_RV233kWBBXox5rc_w-1h1aPua93o9huuPf-pJVuE,18629
 services/retrieval_broker.py,sha256=9X67VZ_6AkbAzopHuuMFKmP4CGZLnW576kjSKMenBnw,5261
 services/router.py,sha256=Cz10nx2fKTbaGn14mSBePWIDrw5rdcs_1JFYXeik084,15626
 services/runtime.py,sha256=b79gN0dFlzBO4rPaUMWier8FZFamMZlwIM3aywLmbB4,12840
+services/scanner.py,sha256=5rMwxAO8Qchz3-GtpZTNwCQDiJIyhAMSXdwNPmTaq-U,4701
 services/session_benchmark.py,sha256=GX3H8OwKC0X9Kk5U-vfY6Y7qq9Qaz2HwadNA7mjO8RY,105047
 services/session_manager.py,sha256=qUo7ool6dDWXfVgFpokIRcWqkWh10OzMcp7aZTdmTHY,51632
 services/session_preloader.py,sha256=DsTAXMKVtrX9yu1sEFojYDi9-jkSAj1Ylt9JTy57Dow,9883
-services/subprojects.py,sha256=DxD-3f4wCrwAg7F8znbvWFJf_lizgmulVDqozKGSztI,24965
+services/subprojects.py,sha256=KNA-qGVPsd7Tg92Pt_kLWMLyER2YHmdQWO44sOelTIg,25123
 services/task_store.py,sha256=IHNeLipdyWtbWYu2-3ItIDeSDI9WoMKj6YwPPc1TgW0,46487
 services/telemetry.py,sha256=KbWCe7F8lGY9DufVPWGyGFo-IBcPgWh0kd3ySJnIgFE,11377
 services/text_index.py,sha256=r3o4CobTG9jAO9PWazgbWYLY9oi_FgEJ3xwEXrF4KM0,2783
@@ -224,8 +226,8 @@ tui/screens/search_view.py,sha256=MMHjVdlk3HZSuDBSvq8IGrqv_Mh5Us6YqXQ80bcWSMk,19
 tui/screens/session_view.py,sha256=eZ1eDwHTvPOck1wCCviixtOaCxIkBT_95ytNNNriGNA,5991
 tui/screens/stats.py,sha256=p81PjzdaIv7hllb8f45-rlVe4lJZwSdIMqu7e86_u5s,6223
 tui/screens/ui_view.py,sha256=1QJCgLh2YfgWIpvzRG1KOGXYEaOYX6ojN61Azjf2oX0,2125
-code_context_control-2.53.0.dist-info/METADATA,sha256=MzVfgzYwfiVSTJz_uGxsENFxI-DJh1ochyB59ewxcuY,24759
-code_context_control-2.53.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-code_context_control-2.53.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
-code_context_control-2.53.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
-code_context_control-2.53.0.dist-info/RECORD,,
+code_context_control-2.54.0.dist-info/METADATA,sha256=jtQEMTmI5Z0UW8uxs6ImKZ8KKA9Fic3IrIgALMBz8zM,24759
+code_context_control-2.54.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+code_context_control-2.54.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
+code_context_control-2.54.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
+code_context_control-2.54.0.dist-info/RECORD,,

services/compressor.py

@@ -709,27 +709,19 @@ class CodeCompressor:
                        '.css', '.html', '.json', '.yaml', '.yml', '.md'}
         allowed = set(extensions) if extensions else default_exts
 
-        # Skip common non-essential dirs
-        skip_dirs = {'node_modules', '.git', '__pycache__', '.c3', 'venv',
-                    'env', '.venv', 'dist', 'build', '.next', '.cache'}
-
         results = []
         total_original = 0
         total_compressed = 0
         skipped_protected = []
 
-        files = sorted(dirpath.rglob('*'))[:max_files * 3]  # Pre-limit
-        count = 0
+        # Pruned walk (shared SKIP_DIRS) - never descends into
+        # node_modules/.git/etc., stops as soon as the cap is reached.
+        from services.scanner import iter_files
 
-        for fpath in files:
+        count = 0
+        for fpath in iter_files(dirpath, exts={e.lower() for e in allowed}):
             if count >= max_files:
                 break
-            if not fpath.is_file():
-                continue
-            if fpath.suffix.lower() not in allowed:
-                continue
-            if any(skip in fpath.parts for skip in skip_dirs):
-                continue
             if self.is_protected_file(fpath):
                 skipped_protected.append(self._relative_to_project(fpath))
                 continue

services/doc_index.py

@@ -92,15 +92,26 @@ class DocIndex:
 
     # --- Build ---
 
-    def build(self, force: bool = False) -> dict:
-        """Build or incrementally update the doc index."""
+    def build(self, force: bool = False, on_progress=None) -> dict:
+        """Build or incrementally update the doc index.
+
+        on_progress: callable(files_done, files_total), invoked per file.
+        """
         stats = {"docs_indexed": 0, "chunks_created": 0, "skipped": 0}
 
         files_to_index = self._discover_files()
         old_hashes = dict(self._file_hashes)
         new_hashes = {}
+        files_total = len(files_to_index)
+        files_done = 0
 
         for rel_path, fpath in files_to_index:
+            files_done += 1
+            if on_progress is not None:
+                try:
+                    on_progress(files_done, files_total)
+                except Exception:
+                    pass
             try:
                 content = fpath.read_text(errors="replace")
             except Exception:
@@ -154,12 +165,6 @@ class DocIndex:
 
     def _discover_files(self) -> list[tuple[str, Path]]:
         """Find all doc, config, and code files to index."""
-        skip_dirs = {
-            "node_modules", ".git", "__pycache__", ".c3", "venv",
-            "env", ".venv", "dist", "build", ".next", ".cache",
-            "coverage", ".pytest_cache",
-        }
-
         # Designated sub-projects keep their own doc index.
         try:
             from services.subprojects import make_excluder
@@ -170,15 +175,14 @@ class DocIndex:
 
         files = []
 
-        # Markdown docs
-        for ext in ("*.md", "*.mdx", "*.rst", "*.adoc"):
-            for fpath in self.project_path.rglob(ext):
-                if any(skip in fpath.parts for skip in skip_dirs):
-                    continue
-                if _sub_excluded(fpath):
-                    continue
-                rel = str(fpath.relative_to(self.project_path))
-                files.append((rel, fpath))
+        # Markdown docs - one pruned walk instead of four full rglob passes
+        from services.scanner import iter_files
+        for fpath in iter_files(self.project_path,
+                                exts={".md", ".mdx", ".rst", ".adoc"}):
+            if _sub_excluded(fpath):
+                continue
+            rel = str(fpath.relative_to(self.project_path))
+            files.append((rel, fpath))
 
         # Config files at project root
         for pattern in _CONFIG_PATTERNS:

services/embedding_index.py

@@ -39,6 +39,8 @@ class EmbeddingIndex:
         self._collection = None
         self._available = False
         self._ollama_ok = False
+        self._ollama_up = False
+        self._model_ok = False
         self._file_hashes: dict[str, str] = {}  # doc_id -> content hash
         self._lock = threading.Lock()
         self._chunk_map: dict[str, dict] = {}  # chunk_id -> metadata
@@ -101,18 +103,47 @@ class EmbeddingIndex:
             self._available = False
 
         try:
-            self._ollama_ok = (
-                self.ollama.is_available(timeout=2)
-                and self.ollama.has_model(self.embed_model)
+            self._ollama_up = self.ollama.is_available(timeout=2)
+            self._model_ok = (
+                self._ollama_up and self.ollama.has_model(self.embed_model)
             )
         except Exception:
-            self._ollama_ok = False
+            self._ollama_up = False
+            self._model_ok = False
+        self._ollama_ok = self._ollama_up and self._model_ok
 
     @property
     def ready(self) -> bool:
         """True when both chromadb and Ollama embeddings are available."""
         return self._available and self._ollama_ok
 
+    def probe(self) -> dict:
+        """Explicitly initialize backends and report readiness.
+
+        ``ready`` alone never triggers backend init (status reporters must
+        stay cheap for build_runtime/MCP handshake), so gating a build on a
+        fresh instance's ``ready`` always skipped. Init/CLI flows call this
+        instead: it pays the one-time backend cost, then reports truthfully.
+        """
+        self._ensure_ready()
+        return {
+            "ready": self.ready,
+            "chromadb": self._available,
+            "ollama": self._ollama_up,
+            "model": self._model_ok,
+        }
+
+    def unavailable_reason(self) -> str:
+        """Human-readable reason ``ready`` is False (after probe/init)."""
+        if not self._available:
+            return "chromadb not installed"
+        if not self._ollama_up:
+            return "Ollama not reachable"
+        if not self._model_ok:
+            return (f"embed model '{self.embed_model}' not pulled "
+                    f"(run: ollama pull {self.embed_model})")
+        return ""
+
     # ── Hash tracking ─────────────────────────────────────
 
     def _load_hashes(self):
@@ -138,12 +169,14 @@ class EmbeddingIndex:
 
     # ── Build / Update ────────────────────────────────────
 
-    def build(self, code_index, force: bool = False) -> dict:
+    def build(self, code_index, force: bool = False, on_progress=None) -> dict:
         """Build or incrementally update the embedding index from CodeIndex chunks.
 
         Args:
             code_index: A CodeIndex instance with populated chunks/documents.
             force: If True, re-embed all files regardless of hash.
+            on_progress: callable(files_done, files_total, chunks_embedded),
+                invoked per file (skipped files count as done).
 
         Returns:
             Stats dict with files_processed, chunks_embedded, chunks_skipped, etc.
@@ -170,6 +203,15 @@ class EmbeddingIndex:
         files_skipped = 0
         errors = 0
         stale_ids = []
+        files_total = len(chunks_by_file)
+
+        def _report():
+            if on_progress is not None:
+                try:
+                    on_progress(files_processed + files_skipped, files_total,
+                                chunks_embedded)
+                except Exception:
+                    pass
 
         with self._lock:
             # Detect deleted files — remove their embeddings
@@ -187,6 +229,7 @@ class EmbeddingIndex:
                 if not force and self._file_hashes.get(doc_id) == new_hash:
                     files_skipped += 1
                     chunks_skipped += len(file_chunks)
+                    _report()
                     continue
 
                 # Remove old chunks for this file before re-embedding
@@ -237,6 +280,7 @@ class EmbeddingIndex:
 
                 self._file_hashes[doc_id] = new_hash
                 files_processed += 1
+                _report()
 
             self._save_hashes()
 

services/indexer.py

@@ -13,6 +13,7 @@ from collections import Counter, OrderedDict
 from pathlib import Path
 
 from core import count_tokens
+from services.scanner import SKIP_DIRS, iter_files
 
 
 class CodeIndex:
@@ -37,10 +38,8 @@ class CodeIndex:
         self._cooccurrence = {}   # term -> {term: count} for auto-synonyms
         self._file_mtimes = {}    # doc_id -> mtime for recency bias
 
-        # Config
-        self.skip_dirs = {'node_modules', '.git', '__pycache__', '.c3', 'venv',
-                         'env', '.venv', 'dist', 'build', '.next', '.cache',
-                         'coverage', '.pytest_cache'}
+        # Config - shared pruned-walk skip set (services/scanner.py)
+        self.skip_dirs = set(SKIP_DIRS)
         self.code_exts = {
             # Python
             '.py', '.pyi', '.pyx',
@@ -87,8 +86,31 @@ class CodeIndex:
             self.exclude_prefixes = []
             self._is_excluded = None
 
-    def build_index(self, max_files: int = 500) -> dict:
-        """Build the full code index."""
+    _DEFAULT_MAX_FILES = 2000
+
+    def _configured_max_files(self) -> int:
+        """``index_max_files`` from .c3/config.json; default 2000."""
+        try:
+            cfg = json.loads((self.project_path / '.c3' / 'config.json')
+                             .read_text(encoding='utf-8'))
+            val = int(cfg.get('index_max_files', self._DEFAULT_MAX_FILES))
+            return val if val > 0 else self._DEFAULT_MAX_FILES
+        except Exception:
+            return self._DEFAULT_MAX_FILES
+
+    def build_index(self, max_files: int = None, on_progress=None) -> dict:
+        """Build the full code index.
+
+        max_files: cap on files indexed. None reads ``index_max_files``
+            from .c3/config.json (default 2000). Traversal continues past
+            the cap only to count what was left out, so callers can report
+            "indexed N of M" instead of silently truncating.
+        on_progress: callable(entries_seen, files_indexed, chunks_created),
+            invoked during the scan (directory granularity plus per file).
+        """
+        if max_files is None:
+            max_files = self._configured_max_files()
+
         self.documents = {}
         self.chunks = {}
         self.symbols = {}
@@ -96,24 +118,35 @@ class CodeIndex:
 
         files_indexed = 0
         chunks_created = 0
+        files_capped = 0
+        scan_stats = {"entries": 0}
 
-        for fpath in sorted(self.project_path.rglob('*')):
-            if files_indexed >= max_files:
-                break
-            if not fpath.is_file():
-                continue
-            if fpath.suffix.lower() not in self.code_exts:
-                continue
-            if any(skip in fpath.parts for skip in self.skip_dirs):
-                continue
-            if self.exclude_prefixes:
+        def _report(entries_seen=None, _yielded=None):
+            if entries_seen is not None:
+                scan_stats["entries"] = entries_seen
+            if on_progress is not None:
                 try:
-                    if self._is_excluded(fpath.relative_to(self.project_path).parts,
-                                         self.exclude_prefixes):
-                        continue
-                except ValueError:
+                    on_progress(scan_stats["entries"], files_indexed,
+                                chunks_created)
+                except Exception:
                     pass
 
+        exclude_parts = None
+        if self.exclude_prefixes and self._is_excluded is not None:
+            def exclude_parts(parts, _c=self._is_excluded,
+                              _p=self.exclude_prefixes):
+                return _c(parts, _p)
+
+        for fpath in iter_files(self.project_path, exts=self.code_exts,
+                                skip_dirs=self.skip_dirs,
+                                exclude_parts=exclude_parts,
+                                on_progress=_report):
+            if files_indexed >= max_files:
+                # Walk on (cheap after pruning) to count coverage;
+                # reading and chunking stop at the cap.
+                files_capped += 1
+                continue
+
             try:
                 content = fpath.read_text(errors='replace')
             except Exception:
@@ -150,6 +183,7 @@ class CodeIndex:
                 pass
 
             files_indexed += 1
+            _report()
 
         # Build TF-IDF and co-occurrence synonyms
         self._build_tfidf()
@@ -162,7 +196,10 @@ class CodeIndex:
             "files_indexed": files_indexed,
             "chunks_created": chunks_created,
             "unique_symbols": len(self.symbols),
-            "index_path": str(self.index_dir)
+            "index_path": str(self.index_dir),
+            "entries_scanned": scan_stats["entries"],
+            "files_capped": files_capped,
+            "max_files": max_files,
         }
 
     def _chunk_file(self, content: str, ext: str, doc_id: str) -> list:

services/protocol.py

@@ -219,42 +219,53 @@ class CompressionProtocol:
         self.custom_dict[term.lower()] = code
         self.save_custom_dict()
 
-    def build_project_dictionary(self) -> dict:
-        """Auto-build a project-specific dictionary from codebase analysis."""
+    def build_project_dictionary(self, code_index=None) -> dict:
+        """Auto-build a project-specific dictionary from codebase analysis.
+
+        code_index: an already-built CodeIndex whose in-memory chunks are
+            mined instead of re-reading the whole tree from disk (init
+            passes the indexer it just built). Without one, falls back to
+            a pruned, capped scan.
+        """
         if not self.project_path.exists():
             return {}
 
         # Find commonly used terms in the project
         term_freq = {}
-        skip_dirs = {'node_modules', '.git', '__pycache__', '.c3', 'venv'}
-        code_exts = {'.py', '.js', '.ts', '.tsx', '.jsx', '.r', '.R'}
-        try:
-            from services.subprojects import make_excluder
-            _sub_excluded = make_excluder(self.project_path)
-        except Exception:
-            def _sub_excluded(_p):
-                return False
-
-        for fpath in self.project_path.rglob('*'):
-            if not fpath.is_file() or fpath.suffix not in code_exts:
-                continue
-            if any(skip in fpath.parts for skip in skip_dirs):
-                continue
-            if _sub_excluded(fpath):
-                continue
-
-            try:
-                content = fpath.read_text(errors='replace')
-            except Exception:
-                continue
+        code_exts = {'.py', '.js', '.ts', '.tsx', '.jsx', '.r'}
 
-            # Extract identifiers
-            identifiers = re.findall(r'\b[a-zA-Z_]\w{5,}\b', content)
-            for ident in identifiers:
+        def _accumulate(text: str):
+            for ident in re.findall(r'\b[a-zA-Z_]\w{5,}\b', text):
                 lower = ident.lower()
                 if lower not in ACTION_CODES and lower not in TERM_CODES:
                     term_freq[lower] = term_freq.get(lower, 0) + 1
 
+        chunks = getattr(code_index, "chunks", None) if code_index else None
+        if chunks:
+            # Sub-project exclusion already applied when the index was built.
+            from pathlib import Path as _P
+            for chunk in chunks.values():
+                if _P(chunk.get("doc_id", "")).suffix.lower() in code_exts:
+                    _accumulate(chunk.get("content", ""))
+        else:
+            from services.scanner import iter_files
+            try:
+                from services.subprojects import make_excluder
+                _sub_excluded = make_excluder(self.project_path)
+            except Exception:
+                def _sub_excluded(_p):
+                    return False
+
+            for fpath in iter_files(self.project_path, exts=code_exts,
+                                    max_files=1000):
+                if _sub_excluded(fpath):
+                    continue
+                try:
+                    content = fpath.read_text(errors='replace')
+                except Exception:
+                    continue
+                _accumulate(content)
+
         # Generate codes for frequent terms
         frequent = sorted(term_freq.items(), key=lambda x: x[1], reverse=True)[:30]
         new_entries = {}

services/scanner.py

@@ -0,0 +1,120 @@
+"""
+Pruned Filesystem Scanner
+
+Shared walker for every C3 index build (code index, doc index, compression
+dictionary, directory compression). Replaces the sorted(Path.rglob('*'))
+pattern, which enumerated every entry under node_modules/.git/venv before
+filtering and materialized the whole tree up front - on large projects that
+meant minutes of stat calls before the first file was even considered.
+
+os.walk with in-place dirnames pruning never descends into skipped
+directories, yields files in deterministic order, exits as soon as the
+caller stops consuming, and reports progress so long scans are visible.
+"""
+import os
+from pathlib import Path
+from typing import Callable, Iterator, Optional, Set, Tuple
+
+# Superset of the historical per-service skip lists.
+# Matched against directory names exactly (never file names).
+SKIP_DIRS = {
+    # original shared set
+    'node_modules', '.git', '__pycache__', '.c3', 'venv', 'env', '.venv',
+    'dist', 'build', '.next', '.cache', 'coverage', '.pytest_cache',
+    # heavyweights the old lists missed
+    'target', '.tox', '.nox', '.eggs', '.mypy_cache', '.ruff_cache',
+    '.gradle', 'Pods', 'obj', '.idea', '.vs', '.svn', '.hg',
+    'bower_components', '.terraform', '.parcel-cache', '.turbo',
+    '.nuxt', '.yarn', '.pnpm-store',
+}
+
+
+def gitignore_dir_names(root) -> set:
+    """Literal directory names from the root .gitignore (best-effort).
+
+    Only unambiguous entries are used - a bare name or ``/name/`` with no
+    wildcard, negation, or nested separator - so pruning can never be
+    broader than the ignore file itself. Data/log directories are exactly
+    what makes large-project scans hang, and they are almost always
+    plain-name entries.
+    """
+    names = set()
+    try:
+        text = (Path(root) / '.gitignore').read_text(errors='replace')
+    except OSError:
+        return names
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith('#') or line.startswith('!'):
+            continue
+        if any(ch in line for ch in '*?['):
+            continue
+        cleaned = line.strip('/')
+        if cleaned and '/' not in cleaned and '\\' not in cleaned:
+            names.add(cleaned)
+    return names
+
+
+def iter_files(
+    root,
+    exts: Optional[Set[str]] = None,
+    skip_dirs: Optional[Set[str]] = None,
+    exclude_parts: Optional[Callable[[Tuple[str, ...]], bool]] = None,
+    max_files: Optional[int] = None,
+    on_progress: Optional[Callable[[int, int], None]] = None,
+    respect_gitignore: bool = True,
+) -> Iterator[Path]:
+    """Yield candidate files under ``root`` with directory-level pruning.
+
+    Args:
+        exts: lowercase suffix allowlist (None = every file).
+        skip_dirs: directory names to prune (default: SKIP_DIRS).
+        exclude_parts: predicate over project-relative path parts; True
+            skips a file, and prunes whole directories before descent
+            (used for sub-project exclusion).
+        max_files: stop traversal entirely after yielding this many.
+        on_progress: called as ``on_progress(entries_seen, files_yielded)``
+            at directory granularity - cheap enough to wire straight to a
+            TTY progress line (which should throttle by time).
+        respect_gitignore: also prune literal directory names listed in
+            the root .gitignore.
+    """
+    root = Path(root)
+    skip = set(SKIP_DIRS if skip_dirs is None else skip_dirs)
+    if respect_gitignore:
+        skip |= gitignore_dir_names(root)
+
+    yielded = 0
+    seen = 0
+    for dirpath, dirnames, filenames in os.walk(str(root), topdown=True,
+                                                followlinks=False):
+        try:
+            rel_parts = Path(dirpath).relative_to(root).parts
+        except ValueError:
+            rel_parts = ()
+
+        kept = []
+        for d in sorted(dirnames):
+            if d in skip:
+                continue
+            if exclude_parts is not None and exclude_parts(rel_parts + (d,)):
+                continue
+            kept.append(d)
+        dirnames[:] = kept
+        seen += len(filenames) + len(kept)
+
+        for fname in sorted(filenames):
+            if exts is not None:
+                if os.path.splitext(fname)[1].lower() not in exts:
+                    continue
+            if exclude_parts is not None and exclude_parts(rel_parts + (fname,)):
+                continue
+            yield Path(dirpath) / fname
+            yielded += 1
+            if max_files is not None and yielded >= max_files:
+                if on_progress is not None:
+                    on_progress(seen, yielded)
+                return
+
+        if on_progress is not None:
+            on_progress(seen, yielded)

services/subprojects.py

@@ -587,7 +587,9 @@ class SubprojectManager:
                 ollama = OllamaClient(cfg.get("ollama_base_url", "http://localhost:11434"))
                 ei = EmbeddingIndex(self.parent_path, ollama,
                                     embed_model=cfg.get("embed_model", "nomic-embed-text"))
-                if ei.ready:
+                # probe() initializes lazy backends; a fresh instance's
+                # .ready is always False and skipped this unconditionally.
+                if ei.probe()["ready"]:
                     detail["embeddings"] = ei.build(indexer, force=True)
             except Exception:
                 pass  # embeddings are best-effort; index/doc exclusion is the contract