code-context-control 2.49.2__tar.gz → 2.51.0__tar.gz

{code_context_control-2.49.2/code_context_control.egg-info → code_context_control-2.51.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.49.2
+Version: 2.51.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). 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.49.2 → code_context_control-2.51.0}/cli/c3.py

@@ -60,7 +60,14 @@ from cli.commands.common import cmd_stats as common_cmd_stats
 from cli.commands.common import cmd_ui as common_cmd_ui
 from cli.commands.parser import build_parser
 from core import count_tokens, format_token_count
-from core.config import AGENT_DEFAULTS, BITBUCKET_DEFAULTS, DELEGATE_DEFAULTS, PROXY_DEFAULTS, load_delegate_config
+from core.config import (
+    AGENT_DEFAULTS,
+    BITBUCKET_DEFAULTS,
+    DELEGATE_DEFAULTS,
+    MEMORY_LLM_DEFAULTS,
+    PROXY_DEFAULTS,
+    load_delegate_config,
+)
 from core.config import DEFAULTS as HYBRID_DEFAULTS
 from core.ide import PROFILES, detect_ide, get_profile, load_ide_config, normalize_ide_name
 from services.compressor import CodeCompressor
@@ -85,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.49.1"
+__version__ = "2.51.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -165,6 +172,7 @@ def _build_init_config(project_path: str) -> dict:
         "delegate": deepcopy(DELEGATE_DEFAULTS),
         "agents": deepcopy(AGENT_DEFAULTS),
         "bitbucket": deepcopy(BITBUCKET_DEFAULTS),
+        "memory_llm": deepcopy(MEMORY_LLM_DEFAULTS),
     }
     merged = _deep_merge_dict(defaults, existing if isinstance(existing, dict) else {})
     # Always persist current path/version on init/update.
@@ -721,6 +729,80 @@ def _select_init_ide(default_ide: str) -> str:
     return chosen
 
 
+def _prompt_memory_llm(project_path: str) -> None:
+    """Interactive memory_llm setup: privacy-first local model + optional cloud opt-in.
+
+    Skipped entirely under --force (that path never enters _prompt_init_steps),
+    which keeps the privacy defaults: distillation on, cloud OFF.
+    """
+    print()
+    choice = _prompt_choice(
+        "Memory — distill each session into durable project facts with an LLM?",
+        [
+            "Local only — a local Ollama model, nothing leaves this machine (recommended)",
+            "Cloud      — a Sonnet-class Ollama Cloud model (API key or signed-in daemon)",
+            "Off        — keep the basic pattern-based capture only",
+        ],
+    )
+    if not choice:
+        return  # EOF/Ctrl+C — keep defaults (local-only, cloud off)
+
+    existing = load_config(project_path).get("memory_llm")
+    section = dict(existing) if isinstance(existing, dict) else {}
+
+    if choice.startswith("Off"):
+        section["enabled"] = False
+        section["cloud_enabled"] = False
+        save_config({"memory_llm": section}, project_path)
+        print("Memory distillation: off (regex capture only).")
+        return
+
+    section["enabled"] = True
+    section["cloud_enabled"] = choice.startswith("Cloud")
+
+    # Local model pick — it is the only tier in local mode and the privacy
+    # fallback tier in cloud mode.
+    default_local = section.get("local_model") or MEMORY_LLM_DEFAULTS["local_model"]
+    models = None
+    try:
+        client = OllamaClient()
+        if client.is_available(timeout=2):
+            models = client.list_models()
+    except Exception:
+        models = None
+    if models:
+        options = [f"Keep default — {default_local}"] + [m for m in models if m != default_local][:8]
+        pick = _prompt_choice("Pick the local model for distillation:", options)
+        if pick and not pick.startswith("Keep default"):
+            section["local_model"] = pick
+    else:
+        print(f"  (Local Ollama not reachable — keeping '{default_local}'; "
+              "change it later in the Settings UI.)")
+
+    if section["cloud_enabled"]:
+        if os.environ.get("OLLAMA_API_KEY"):
+            print("  Cloud key: using OLLAMA_API_KEY from the environment.")
+        else:
+            try:
+                key = input("  Paste Ollama Cloud API key (Enter to skip — a signed-in "
+                            "local daemon also works): ").strip()
+            except (EOFError, KeyboardInterrupt):
+                key = ""
+            if key:
+                try:
+                    from services.ollama_credentials import save_api_key
+                    save_api_key(key, section.get("cloud_base_url")
+                                 or MEMORY_LLM_DEFAULTS["cloud_base_url"])
+                    print("  Key stored in the OS keyring (never in config.json).")
+                except Exception as exc:
+                    print(f"  Could not store key in keyring ({exc}); "
+                          "set the OLLAMA_API_KEY environment variable instead.")
+
+    save_config({"memory_llm": section}, project_path)
+    print("Memory distillation: "
+          + ("cloud + local fallback." if section["cloud_enabled"] else "local only (private)."))
+
+
 def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "direct") -> tuple[str, bool]:
     """Run guided post-init setup steps for Git and MCP."""
     chosen_ide = _select_init_ide(ide_name or "auto")
@@ -739,6 +821,8 @@ def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "di
     else:
         print("Git: skipped.")
 
+    _prompt_memory_llm(project_path)
+
     print()
     install_choice = _prompt_choice(
         "Step 3/3 — Install MCP tooling for this project?",
@@ -5030,6 +5114,7 @@ def cmd_install_mcp(args):
         hook_pretool_cmd  = f"{_dispatch_base} pretool"
         hook_posttool_cmd = f"{_dispatch_base} posttool"
         hook_stop_cmd     = f"{_dispatch_base} stop"
+        hook_prompt_cmd   = f"{_dispatch_base} prompt"
 
         # Tool matcher names differ by IDE: Gemini uses snake_case built-in names.
         if profile.name == "gemini":
@@ -5153,6 +5238,28 @@ def cmd_install_mcp(args):
         existing_stop.extend(desired_stop_hooks)
         settings.setdefault("hooks", {})[stop_event] = existing_stop
 
+        # ── UserPromptSubmit hook (per-prompt project-memory injection) ──
+        # Claude Code only: Gemini CLI has no equivalent hook event. Same
+        # merge discipline as Stop: replace only C3's own entries (identified
+        # by the dispatcher script in the command), keep user-added ones.
+        if profile.name != "gemini":
+            prompt_event = "UserPromptSubmit"
+
+            def _is_c3_prompt_hook(entry: dict) -> bool:
+                return any(
+                    "hook_dispatch.py" in (hk.get("command") or "")
+                    for hk in entry.get("hooks", [])
+                )
+
+            existing_prompt = [
+                h for h in settings.get("hooks", {}).get(prompt_event, [])
+                if not _is_c3_prompt_hook(h)
+            ]
+            existing_prompt.append(
+                {"matcher": "", "hooks": [{"type": "command", "command": hook_prompt_cmd}]}
+            )
+            settings.setdefault("hooks", {})[prompt_event] = existing_prompt
+
         # Claude Code only: enable MCP server prompt settings
         if profile.name == "claude-code":
             settings["enableAllProjectMcpServers"] = True

{code_context_control-2.49.2 → code_context_control-2.51.0}/cli/hook_dispatch.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Per-event hook dispatcher: ONE process per Claude Code / Gemini hook event.
 
-Usage: python hook_dispatch.py <pretool|posttool|stop>
+Usage: python hook_dispatch.py <pretool|posttool|stop|prompt>
 
 Before v2.42 every hook was registered as its own "cmd /c python <hook>.py"
 subprocess, so a single native Read fired up to three interpreter spawns
@@ -46,7 +46,7 @@ sys.modules.setdefault("_hook_utils", _hook_utils)
 
 from cli._hook_utils import log_hook_error, normalize_tool_name  # noqa: E402
 
-VALID_EVENTS = ("pretool", "posttool", "stop")
+VALID_EVENTS = ("pretool", "posttool", "stop", "prompt")
 
 # ── Routing tables (parity with the pre-v2.42 per-matcher registration) ─────
 
@@ -103,6 +103,8 @@ def _routes(event: str, raw_tool: str, norm_tool: str):
         yield "hook_session_stats"
         yield "hook_auto_snapshot"
         yield "hook_terse_advisor"
+    elif event == "prompt":
+        yield "hook_prompt_recall"
 
 
 _RUN_CACHE: dict = {}
@@ -128,7 +130,8 @@ def _load_run(module_name: str):
     return result
 
 
-def merge_outputs(outputs: list, warnings: list, is_gemini: bool = False) -> dict | None:
+def merge_outputs(outputs: list, warnings: list, is_gemini: bool = False,
+                  event: str = "") -> dict | None:
     """Compose sub-hook outputs per Claude Code hook semantics.
 
     - deny beats allow: the first hookSpecificOutput carrying a
@@ -186,6 +189,14 @@ def merge_outputs(outputs: list, warnings: list, is_gemini: bool = False) -> dic
     if texts:
         result["_text"] = "\n".join(texts)
 
+    # UserPromptSubmit expects context under hookSpecificOutput (the
+    # top-level additionalContext key is a PostToolUse shape).
+    if event == "prompt" and result.get("additionalContext"):
+        result["hookSpecificOutput"] = {
+            "hookEventName": "UserPromptSubmit",
+            "additionalContext": result.pop("additionalContext"),
+        }
+
     return result or None
 
 
@@ -220,7 +231,7 @@ def dispatch(event: str, payload: dict, project_path: Path | None = None) -> dic
         # become visible instead of silently disabling enforcement.
         warnings.extend(_hook_utils.drain_state_warnings())
 
-    return merge_outputs(outputs, warnings, is_gemini=is_gemini)
+    return merge_outputs(outputs, warnings, is_gemini=is_gemini, event=event)
 
 
 def main() -> None:

code_context_control-2.51.0/cli/hook_prompt_recall.py

@@ -0,0 +1,97 @@
+"""UserPromptSubmit hook: inject relevant project memory into each prompt.
+
+STRICTLY READ-ONLY. Loads .c3/facts/facts.json directly and ranks with the
+pure-stdlib TextIndex. Never instantiates MemoryStore — its recall() writes
+telemetry back to facts.json, and this hook runs in a separate process from
+the live MCP server (double-writer clobber). Never imports the runtime/ML
+stack — the whole hook must stay well under a second.
+
+Output is capped to memory_llm.inject_max_tokens (~400 tokens default).
+Any failure returns None: memory injection is never worth breaking a prompt.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+_MIN_PROMPT_CHARS = 15
+_LINE_CAP = 220
+_WALK_UP_LEVELS = 4
+
+
+def _find_project(payload: dict, project_path=None) -> Path | None:
+    candidates = []
+    if project_path:
+        candidates.append(Path(project_path))
+    if payload.get("cwd"):
+        candidates.append(Path(str(payload["cwd"])))
+    for base in candidates:
+        node = base
+        for _ in range(_WALK_UP_LEVELS):
+            if (node / ".c3").is_dir():
+                return node
+            if node.parent == node:
+                break
+            node = node.parent
+    return None
+
+
+def run(payload: dict, project_path=None) -> dict | None:
+    try:
+        prompt = str(payload.get("prompt") or "").strip()
+        if len(prompt) < _MIN_PROMPT_CHARS:
+            return None
+        project = _find_project(payload, project_path)
+        if project is None:
+            return None
+        try:
+            cfg = json.loads((project / ".c3" / "config.json").read_text(encoding="utf-8"))
+        except Exception:
+            cfg = {}
+        mem_cfg = cfg.get("memory_llm", {}) if isinstance(cfg, dict) else {}
+        if not mem_cfg.get("prompt_inject_enabled", True):
+            return None
+        try:
+            facts = json.loads(
+                (project / ".c3" / "facts" / "facts.json").read_text(encoding="utf-8"))
+        except Exception:
+            return None
+        if not isinstance(facts, list) or not facts:
+            return None
+
+        from services.text_index import TextIndex  # pure stdlib (math/re/collections)
+        index = TextIndex()
+        by_id: dict = {}
+        for fact in facts:
+            if not isinstance(fact, dict):
+                continue
+            if fact.get("lifecycle", "active") != "active":
+                continue
+            fid, text = fact.get("id"), fact.get("fact", "")
+            if not fid or not text:
+                continue
+            by_id[fid] = fact
+            index.add_or_update(fid, f"{text} {fact.get('category', '')}")
+        if not by_id:
+            return None
+
+        hits = index.search(prompt, top_k=max(1, int(mem_cfg.get("inject_top_k", 4))))
+        max_chars = int(mem_cfg.get("inject_max_tokens", 400)) * 4
+        lines = ["[c3:memory] Possibly relevant project facts:"]
+        used = len(lines[0])
+        for fid, score in hits:
+            if score <= 0:
+                continue
+            fact = by_id[fid]
+            body = " ".join(str(fact.get("fact", "")).split())[:_LINE_CAP]
+            line = f"- ({fact.get('category', 'general')}) {body}"
+            if used + len(line) > max_chars:
+                break
+            lines.append(line)
+            used += len(line)
+        if len(lines) < 2:
+            return None
+        return {"additionalContext": "\n".join(lines)}
+    except Exception:
+        return None

{code_context_control-2.49.2 → code_context_control-2.51.0}/cli/hub_server.py

@@ -1574,9 +1574,13 @@ def api_search_global():
                     "results": results, "skipped": skipped})
 
 
-_CONFIG_READ_SECTIONS = ("hybrid", "agents", "delegate", "proxy", "mcp", "bitbucket", "meta")
-_CONFIG_WRITE_SECTIONS = ("hybrid", "agents", "delegate", "proxy", "mcp", "meta")
-_CONFIG_REFUSED_KEYS = ("version", "project_path", "permission_tier", "subprojects", "parent")
+_CONFIG_READ_SECTIONS = ("hybrid", "agents", "delegate", "proxy", "mcp", "bitbucket", "meta",
+                         "memory_llm")
+_CONFIG_WRITE_SECTIONS = ("hybrid", "agents", "delegate", "proxy", "mcp", "meta", "memory_llm")
+# api_key: secrets never transit the hub or land in config.json — the Ollama
+# cloud key lives in the OS keyring (project Settings UI / OLLAMA_API_KEY env).
+_CONFIG_REFUSED_KEYS = ("version", "project_path", "permission_tier", "subprojects", "parent",
+                        "api_key")
 
 
 def _config_defaults(section: str) -> dict:
@@ -1589,6 +1593,7 @@ def _config_defaults(section: str) -> dict:
         "bitbucket": core_config.BITBUCKET_DEFAULTS,
         "mcp": {"mode": "direct"},
         "meta": {},
+        "memory_llm": core_config.MEMORY_LLM_DEFAULTS,
     }.get(section, {})
 
 

{code_context_control-2.49.2 → code_context_control-2.51.0}/cli/hub_ui/components/config_editor.js

@@ -3,9 +3,9 @@
 // PUT {path, section, values} (writable sections only). The
 // bitbucket section is shown read-only; server-refused keys hidden.
 
-const CFG_ED_SECTIONS = ['hybrid', 'agents', 'delegate', 'proxy', 'mcp', 'meta', 'bitbucket'];
+const CFG_ED_SECTIONS = ['hybrid', 'agents', 'delegate', 'proxy', 'mcp', 'meta', 'memory_llm', 'bitbucket'];
 const CFG_ED_READONLY = ['bitbucket'];
-const CFG_ED_REFUSED = ['version', 'project_path', 'permission_tier', 'subprojects', 'parent'];
+const CFG_ED_REFUSED = ['version', 'project_path', 'permission_tier', 'subprojects', 'parent', 'api_key'];
 
 function ConfigEditor({ project }) {
   const [section, setSection] = useState('hybrid');
@@ -205,6 +205,12 @@ function ConfigEditor({ project }) {
               This section is read-only in the hub (credentials live in the OS keyring — use <span className="mono">c3 bitbucket login</span>).
             </div>
           )}
+          {section === 'memory_llm' && (
+            <div style={{ fontSize: 11, color: T.textMuted, marginBottom: 10 }}>
+              <span className="mono">cloud_enabled</span> sends session content to Ollama Cloud — leave off for local-only privacy (<span className="mono">local_model</span> is used instead).
+              The cloud API key is not editable here: it lives in the OS keyring — set it in the project's Settings tab or via <span className="mono">OLLAMA_API_KEY</span>.
+            </div>
+          )}
           {keys.length === 0 && <DrillMsg text="No editable keys in this section." />}
           <div style={{ display: 'flex', flexDirection: 'column' }}>
             {keys.map(renderField)}

{code_context_control-2.49.2 → code_context_control-2.51.0}/cli/mcp_server.py

@@ -283,6 +283,18 @@ async def lifespan(server):
                 services.auto_memory.on_session_end()
             except Exception:
                 pass
+        # Memory distillation: durably enqueue a digest job while the session
+        # is still current. Processing happens at the END of this finally
+        # block (after save_session + convo sync) so the inline pass sees the
+        # richest material; if the process dies first, the job file survives
+        # and the next session's MemoryDistillerAgent drains it.
+        _distill_job = None
+        if getattr(services, "memory_distiller", None):
+            try:
+                _distill_job = services.memory_distiller.enqueue_session(
+                    services.session_mgr.current_session)
+            except Exception:
+                _distill_job = None
         # Memory consolidation: triage + prune at session end (lightweight).
         if services.memory_consolidator:
             try:
@@ -301,6 +313,17 @@ async def lifespan(server):
                     services.retrieval.mark_sessions_dirty()
             except Exception:
                 pass
+        # Best-effort inline distillation. A daemon thread dies with the
+        # interpreter without blocking shutdown — the queued job is the
+        # durable fallback either way.
+        if _distill_job and getattr(services, "memory_distiller", None):
+            try:
+                threading.Thread(
+                    target=services.memory_distiller.process_job_safe,
+                    args=(_distill_job,), daemon=True,
+                    name="c3-memory-distill").start()
+            except Exception:
+                pass
 
 
 mcp = FastMCP(f"C3 v{C3_VERSION}", instructions=_build_instructions(_IDE_NAME), lifespan=lifespan)

{code_context_control-2.49.2 → code_context_control-2.51.0}/cli/server.py

@@ -2457,6 +2457,71 @@ def api_ollama_models():
     return jsonify({"models": models})
 
 
+@app.route('/api/memory-llm/config', methods=['GET'])
+def api_memory_llm_config_get():
+    """Get memory_llm config (merged with defaults). Never returns the API key."""
+    from core.config import load_memory_llm_config
+    cfg = load_memory_llm_config(str(PROJECT_PATH))
+    key_set = False
+    try:
+        from services.ollama_credentials import api_key_available
+        key_set = api_key_available(cfg.get("cloud_base_url", ""),
+                                    cfg.get("api_key_env", ""),
+                                    cfg.get("api_key", ""))
+    except Exception:
+        pass
+    cfg["api_key"] = "*****" if cfg.get("api_key") else ""
+    cfg["api_key_set"] = bool(key_set)
+    return jsonify(cfg)
+
+
+@app.route('/api/memory-llm/config', methods=['PUT'])
+def api_memory_llm_config_put():
+    """Update memory_llm config. Persists to .c3/config.json (never the key)."""
+    from core.config import MEMORY_LLM_DEFAULTS, load_memory_llm_config
+    data = request.get_json() or {}
+    # api_key is keyring-only (set via /api/memory-llm/key) — config.json is
+    # not gitignored by default, so a plaintext key there could get committed.
+    allowed_keys = set(MEMORY_LLM_DEFAULTS.keys()) - {"api_key"}
+    updates = {k: v for k, v in data.items() if k in allowed_keys}
+
+    if not updates:
+        return jsonify({"error": "No valid memory_llm config keys to update"}), 400
+
+    config_path = PROJECT_PATH / ".c3" / "config.json"
+    config = {}
+    if config_path.exists():
+        try:
+            with open(config_path, encoding="utf-8") as f:
+                config = json.load(f)
+        except Exception:
+            pass
+    config.setdefault("memory_llm", {}).update(updates)
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+    return jsonify(load_memory_llm_config(str(PROJECT_PATH)))
+
+
+@app.route('/api/memory-llm/key', methods=['POST'])
+def api_memory_llm_key_set():
+    """Store (or clear, with an empty key) the Ollama Cloud API key in the OS keyring."""
+    from core.config import load_memory_llm_config
+    from services.ollama_credentials import delete_api_key, save_api_key
+    data = request.get_json() or {}
+    key = str(data.get("key") or "").strip()
+    base = load_memory_llm_config(str(PROJECT_PATH)).get("cloud_base_url", "")
+    if not key:
+        removed = delete_api_key(base)
+        return jsonify({"cleared": bool(removed), "api_key_set": False})
+    try:
+        save_api_key(key, base)
+    except Exception as exc:
+        return jsonify({"error": str(exc)}), 500
+    return jsonify({"api_key_set": True})
+
+
 @app.route('/api/delegate', methods=['POST'])
 def api_delegate():
     """Delegate a task to local LLM with optional streaming."""

{code_context_control-2.49.2 → code_context_control-2.51.0}/cli/tools/_helpers.py

@@ -3,9 +3,57 @@
 from pathlib import Path
 
 
-def maybe_related_facts(svc, topic: str, top_k: int = 3, width: int = 100) -> str:
-    """Append related facts if enabled. Currently disabled — adds noise."""
-    return ""
+def maybe_related_facts(svc, topic: str, top_k: int = 3, width: int = 100,
+                        context: str = "") -> str:
+    """Format facts related to `topic` as compact advisory lines.
+
+    Enabled ONLY for the read path (context="read", gated by
+    memory_llm.read_related_facts_enabled): a gotcha about the file being
+    read is worth the tokens at that moment. Search/compress callers stay
+    disabled — facts surfaced next to ranked search output were noise.
+    """
+    if context != "read":
+        return ""
+    try:
+        cfg = getattr(svc, "_memory_llm_cfg", None)
+        if cfg is None:
+            from core.config import load_memory_llm_config
+            cfg = load_memory_llm_config(str(getattr(svc, "project_path", ".")))
+            try:
+                svc._memory_llm_cfg = cfg
+            except Exception:
+                pass
+        if not cfg.get("read_related_facts_enabled", True):
+            return ""
+        memory = getattr(svc, "memory", None)
+        if memory is None:
+            return ""
+        path = Path(topic)
+        query = " ".join(filter(None, [
+            path.name, path.stem.replace("_", " "), path.parent.name]))
+        hits = memory.recall(query, top_k=max(top_k, 3))
+        if not hits:
+            return ""
+        # Relative score floor: recall scores are scale-free (TF-IDF-only when
+        # the vector backend is off), so an absolute threshold misfires.
+        top_score = max(float(h.get("score", 0) or 0) for h in hits)
+        floor = max(0.05, 0.3 * top_score)
+        lines = []
+        for hit in hits:
+            if float(hit.get("score", 0) or 0) < floor:
+                continue
+            category = str(hit.get("category", "") or "general")
+            if category.startswith("auto:"):
+                continue
+            body = " ".join(str(hit.get("fact", "")).split())
+            if not body:
+                continue
+            lines.append(f"[c3:related] ({category}) {body[:width]}")
+            if len(lines) >= top_k:
+                break
+        return ("\n" + "\n".join(lines)) if lines else ""
+    except Exception:
+        return ""
 
 
 # ── Response boilerplate diet (P6) ───────────────────────────────────────────