code-context-control 2.35.0__py3-none-any.whl → 2.37.0__py3-none-any.whl

cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.35.0"
+__version__ = "2.37.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -379,6 +379,44 @@ def _build_permission_tier(tier: str, include_mcp_wildcard: bool = False) -> dic
     }}
 
 
+def _c3_managed_permission_entries() -> tuple[set, set]:
+    """Return (allow, deny) sets of every entry any C3 tier can emit.
+
+    Used to tell C3-managed permission rules apart from user-added ones so a
+    tier change replaces only the former and preserves the latter.
+    """
+    managed_allow: set = set()
+    managed_deny: set = set()
+    for _tier in PERMISSION_TIERS:
+        perms = _build_permission_tier(_tier, include_mcp_wildcard=True)["permissions"]
+        managed_allow.update(perms.get("allow", []))
+        managed_deny.update(perms.get("deny", []))
+    return managed_allow, managed_deny
+
+
+def _merge_permission_tier(existing: dict, tier_perms: dict) -> dict:
+    """Merge a tier's permissions into existing ones, preserving user rules.
+
+    C3 owns every entry a tier can emit: those are replaced by the chosen tier.
+    Any other allow/deny entry the user added is kept, and non-list permission
+    keys (e.g. ``ask``, ``defaultMode``, ``additionalDirectories``) are left
+    untouched. Mirrors how hooks and .mcp.json preserve non-C3 content.
+    """
+    existing = existing if isinstance(existing, dict) else {}
+    managed = dict(zip(("allow", "deny"), _c3_managed_permission_entries()))
+    merged = dict(existing)  # preserve unknown sub-keys (ask, defaultMode, ...)
+    for key in ("allow", "deny"):
+        user_custom = [e for e in (existing.get(key) or []) if e not in managed[key]]
+        out: list = []
+        seen: set = set()
+        for entry in user_custom + list(tier_perms.get(key) or []):
+            if entry not in seen:
+                seen.add(entry)
+                out.append(entry)
+        merged[key] = out
+    return merged
+
+
 def _detect_current_tier(settings_path) -> str | None:
     """Detect which permission tier is active in settings_path, or None.
 
@@ -456,9 +494,12 @@ def _apply_permission_tier(project_path: str, tier: str,
     settings_path = Path(project_path) / ".claude" / "settings.local.json"
     settings_path.parent.mkdir(parents=True, exist_ok=True)
     settings = _safe_read_json(settings_path, str(settings_path))
-    settings["permissions"] = _build_permission_tier(
+    tier_perms = _build_permission_tier(
         tier, include_mcp_wildcard=include_mcp_wildcard
     )["permissions"]
+    settings["permissions"] = _merge_permission_tier(
+        settings.get("permissions") or {}, tier_perms
+    )
     # Persist chosen tier in .c3/config.json
     c3_config_path = Path(project_path) / ".c3" / "config.json"
     c3_config = _safe_read_json(c3_config_path, str(c3_config_path))
@@ -912,6 +953,12 @@ def cmd_init(args):
              health["instructions_file"] + " missing" not in " ".join(health["issues"])
              else " [MISSING]"))
 
+    # Version-skew notice: this project's .c3 was written by an older C3.
+    stored_version = _safe_read_json(c3_dir / "config.json", "config").get("version")
+    if stored_version and _version_tuple(str(stored_version)) < _version_tuple(__version__):
+        print(f"\n  [upgrade] Set up with C3 v{stored_version}; now running v{__version__}.")
+        print("            Run 'c3 init . --force' to re-apply MCP config, hooks, and docs.")
+
     # Permission status (Claude Code only) — surface tier + stale-tool drift
     try:
         from core.ide import load_ide_config as _load_ide
@@ -3872,8 +3919,8 @@ _AGENTS_MD_CONTENT = _C3_COMPACT_WORKFLOW + """
 This project uses project-scoped MCP servers. Ensure your `.codex/config.toml` includes:
 ```toml
 [mcp_servers.c3]
-command = "python"
-args = ["<path-to-c3>/cli/mcp_server.py", "--project", "."]
+command = "c3-mcp"
+args = ["--project", "."]
 enabled = true
 ```
 """
@@ -3886,8 +3933,8 @@ This project uses project-scoped MCP servers. Ensure your `.gemini/settings.json
 {
   "mcpServers": {
     "c3": {
-      "command": "python",
-      "args": ["<path-to-c3>/cli/mcp_server.py", "--project", "."]
+      "command": "c3-mcp",
+      "args": ["--project", "."]
     }
   }
 }
@@ -4215,11 +4262,17 @@ def _upsert_json_mcp_server(config_path: Path, config_key: str, server_name: str
     return "updated" if previous_entry is not None else "written"
 
 
-def _ensure_project_session_configs(target: Path, server_script: str, primary_profile: str | None = None) -> None:
+def _ensure_project_session_configs(target: Path, server_script: str, primary_profile: str | None = None,
+                                    c3_mcp_exe: str | None = None) -> None:
     """Keep project-local Codex and Gemini MCP configs in sync for new sessions."""
     # Ensure forward slashes for config portability and avoid Windows path-splitting issues
     server_script_posix = Path(server_script).as_posix()
-    server_args = [server_script_posix, "--project", target.as_posix()]
+    if c3_mcp_exe:
+        mcp_command = c3_mcp_exe
+        server_args = ["--project", target.as_posix()]
+    else:
+        mcp_command = "python"
+        server_args = [server_script_posix, "--project", target.as_posix()]
 
     if primary_profile != "codex":
         codex_path = target / ".codex" / "config.toml"
@@ -4228,7 +4281,7 @@ def _ensure_project_session_configs(target: Path, server_script: str, primary_pr
             codex_path,
             "mcp_servers.c3",
             {
-                "command": "python",
+                "command": mcp_command,
                 "args": server_args,
                 "enabled": True,
             },
@@ -4242,14 +4295,14 @@ def _ensure_project_session_configs(target: Path, server_script: str, primary_pr
             "mcpServers",
             "c3",
             {
-                "command": "python",
+                "command": mcp_command,
                 "args": server_args,
             },
         )
         print(f"{gemini_state.capitalize()} {gemini_path}")
 
 
-def _ensure_global_session_fallbacks(server_script: str) -> None:
+def _ensure_global_session_fallbacks(server_script: str, c3_mcp_exe: str | None = None) -> None:
     """Keep user-global Codex/Gemini MCP configs pointing at C3.
 
     These fallback entries omit `--project` so the MCP server can resolve the
@@ -4257,7 +4310,9 @@ def _ensure_global_session_fallbacks(server_script: str) -> None:
     does not yet have project-local Codex/Gemini config files.
     """
     server_script_posix = Path(server_script).as_posix()
-    fallback_args = [server_script_posix]
+    # With the installed entry point, no script path is needed; --project stays
+    # omitted so the server resolves the working directory at session start.
+    fallback_args = [] if c3_mcp_exe else [server_script_posix]
 
     codex_path = Path.home() / ".codex" / "config.toml"
     try:
@@ -4266,7 +4321,7 @@ def _ensure_global_session_fallbacks(server_script: str) -> None:
             codex_path,
             "mcp_servers.c3",
             {
-                "command": "python",
+                "command": c3_mcp_exe or "python",
                 "args": fallback_args,
                 "enabled": True,
             },
@@ -4282,7 +4337,7 @@ def _ensure_global_session_fallbacks(server_script: str) -> None:
             "mcpServers",
             "c3",
             {
-                "command": sys.executable,
+                "command": c3_mcp_exe or sys.executable,
                 "args": fallback_args,
             },
         )
@@ -4825,13 +4880,25 @@ def cmd_install_mcp(args):
     # Use forward slashes for cross-platform compatibility in config files
     server_script = (cli_dir / server_filename).as_posix()
 
-    # Use 'python' for project-scoped IDE configs to be portable in templates,
-    # but use sys.executable for the actual config write to be precise.
-    # On Windows, Gemini CLI splits command args by space, so we must quote the script path.
-    new_entry = {
-        "command": "python",
-        "args": [server_script, "--project", "."],
-    }
+    # Prefer the installed `c3-mcp` console script for direct mode. It survives C3
+    # upgrades (pip/pipx reinstall to the same launcher path) and keeps the source-tree
+    # location out of every project's MCP config, so upgrading no longer requires
+    # re-running install-mcp per project. Fall back to invoking the source script with
+    # `python` when running from a checkout with no installed entry point, or in proxy
+    # mode (which has no console script).
+    import shutil
+    c3_mcp_exe = None
+    if mcp_mode != "proxy":
+        _found = shutil.which("c3-mcp")
+        if _found:
+            c3_mcp_exe = Path(_found).resolve().as_posix()
+
+    # On Windows, Gemini CLI splits command args by space, so the script path stays a
+    # single arg. 'python' keeps the source fallback portable across platforms.
+    if c3_mcp_exe:
+        new_entry = {"command": c3_mcp_exe, "args": ["--project", "."]}
+    else:
+        new_entry = {"command": "python", "args": [server_script, "--project", "."]}
     if profile.needs_type_field:
         new_entry["type"] = "stdio"
 
@@ -4865,7 +4932,10 @@ def cmd_install_mcp(args):
     try:
         if profile.config_format == "toml":
             # Codex uses TOML: [mcp_servers.c3] with command/args
-            toml_entries = {"command": sys.executable, "args": [server_script, "--project", str(target)]}
+            if c3_mcp_exe:
+                toml_entries = {"command": c3_mcp_exe, "args": ["--project", str(target)]}
+            else:
+                toml_entries = {"command": sys.executable, "args": [server_script, "--project", str(target)]}
             if profile.name == "codex":
                 # Codex supports explicit enable/disable per server.
                 toml_entries["enabled"] = True
@@ -4895,8 +4965,8 @@ def cmd_install_mcp(args):
 
     print(f"Wrote {mcp_config_path}")
     if profile.name in {"codex", "gemini"}:
-        _ensure_project_session_configs(target, server_script, primary_profile=profile.name)
-        _ensure_global_session_fallbacks(server_script)
+        _ensure_project_session_configs(target, server_script, primary_profile=profile.name, c3_mcp_exe=c3_mcp_exe)
+        _ensure_global_session_fallbacks(server_script, c3_mcp_exe=c3_mcp_exe)
 
     # ── Persist IDE choice to .c3/config.json ──
     c3_config_dir = target / ".c3"
@@ -5110,10 +5180,23 @@ def cmd_install_mcp(args):
             },
         ]
         stop_event = "Stop"
-        # Replace any existing C3 stop hooks (matcher=""), keep user-added ones
+        # Replace only C3's own stop hooks (identified by our hook scripts) and
+        # keep every user-added stop hook — including matcher-less ones, which
+        # are the normal shape for Stop hooks.
+        _c3_stop_scripts = (
+            "hook_session_stats.py", "hook_auto_snapshot.py", "hook_terse_advisor.py",
+        )
+
+        def _is_c3_stop_hook(entry: dict) -> bool:
+            return any(
+                script in (hk.get("command") or "")
+                for hk in entry.get("hooks", [])
+                for script in _c3_stop_scripts
+            )
+
         existing_stop = [
             h for h in settings.get("hooks", {}).get(stop_event, [])
-            if h.get("matcher")  # keep entries with a non-empty matcher
+            if not _is_c3_stop_hook(h)
         ]
         existing_stop.extend(desired_stop_hooks)
         settings.setdefault("hooks", {})[stop_event] = existing_stop
@@ -5131,9 +5214,12 @@ def cmd_install_mcp(args):
         include_wildcard = bool(getattr(args, "include_mcp_wildcard", False))
         if perm_tier and profile.name == "claude-code":
             if perm_tier in PERMISSION_TIERS:
-                settings["permissions"] = _build_permission_tier(
-                    perm_tier, include_mcp_wildcard=include_wildcard
-                )["permissions"]
+                settings["permissions"] = _merge_permission_tier(
+                    settings.get("permissions") or {},
+                    _build_permission_tier(
+                        perm_tier, include_mcp_wildcard=include_wildcard
+                    )["permissions"],
+                )
                 # Persist tier choice in .c3/config.json
                 _c3cfg = _safe_read_json(c3_config_path, str(c3_config_path))
                 _c3cfg["permission_tier"] = perm_tier
@@ -6342,6 +6428,123 @@ def _run_swe_bench_lite(args, project_path):
         pass
 
 
+def _version_tuple(v: str) -> tuple:
+    """Best-effort numeric version tuple for comparisons ('2.36.0' -> (2, 36, 0))."""
+    parts = []
+    for chunk in str(v or "").split("."):
+        digits = ""
+        for ch in chunk:
+            if ch.isdigit():
+                digits += ch
+            else:
+                break
+        parts.append(int(digits) if digits else 0)
+    return tuple(parts) or (0,)
+
+
+def _latest_pypi_version(package: str = "code-context-control", timeout: float = 5.0) -> str | None:
+    """Best-effort latest release of `package` on PyPI; None if unreachable."""
+    import urllib.request
+    try:
+        url = f"https://pypi.org/pypi/{package}/json"
+        with urllib.request.urlopen(url, timeout=timeout) as resp:
+            data = json.loads(resp.read().decode("utf-8", "replace"))
+        return (data.get("info") or {}).get("version")
+    except Exception:
+        return None
+
+
+def _installed_distribution(package: str = "code-context-control"):
+    """Return the installed Distribution for `package`, or None when running from source."""
+    try:
+        from importlib import metadata
+        return metadata.distribution(package)
+    except Exception:
+        return None
+
+
+def _is_editable_install(package: str = "code-context-control") -> bool:
+    """True when `package` is pip-installed in editable/development mode."""
+    dist = _installed_distribution(package)
+    if dist is None:
+        return False
+    try:
+        text = dist.read_text("direct_url.json")
+        if text:
+            return bool(json.loads(text).get("dir_info", {}).get("editable"))
+    except Exception:
+        pass
+    return False
+
+
+def cmd_upgrade(args):
+    """Upgrade C3 to the latest PyPI release (or just check with --check)."""
+    current = __version__
+    latest = _latest_pypi_version()
+    if latest is None:
+        print("  Could not reach PyPI to check for updates (offline?).")
+    elif _version_tuple(latest) <= _version_tuple(current):
+        print(f"  C3 is up to date (v{current}).")
+        return
+    else:
+        print(f"  Update available: v{current} -> v{latest}")
+
+    if getattr(args, "check", False):
+        return
+
+    if _installed_distribution() is None:
+        print("  C3 is running from a source checkout (not pip-installed).")
+        print("  Update with:  git pull")
+        return
+    if _is_editable_install():
+        print("  C3 is installed in editable/development mode (pip install -e .).")
+        print("  Update with:  git pull")
+        return
+
+    print("  Upgrading via pip (this may take a minute)...")
+    cmd = [sys.executable, "-m", "pip", "install", "-U", "code-context-control[tui]"]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True)
+    except Exception as e:
+        print(f"  Upgrade failed to launch pip: {e}")
+        sys.exit(1)
+    if result.returncode != 0:
+        print("  pip upgrade failed:")
+        print((result.stderr or result.stdout or "").strip()[-1000:])
+        sys.exit(1)
+    print("  Upgraded to the latest release. Restart your IDE's MCP server to load it.")
+    print("  In each project, run  c3 init . --force  to apply any migrations.")
+
+
+def _launch_tui() -> None:
+    """Launch the interactive TUI — what `c3` with no arguments does.
+
+    Runs tui/main.py as a subprocess so its bare `from screens...` imports resolve
+    (its own directory lands on sys.path[0]); the package root goes on PYTHONPATH for
+    cli/services imports. Falls back to help text when the optional [tui] extra
+    (textual) is not installed.
+    """
+    pkg_root = Path(__file__).resolve().parent.parent
+    tui_main = pkg_root / "tui" / "main.py"
+    try:
+        import textual  # noqa: F401
+    except Exception:
+        print("The interactive TUI needs the optional 'textual' dependency.")
+        print('  Install it with:  pip install "code-context-control[tui]"')
+        print("  Or run  c3 --help  to see all commands.")
+        return
+    if not tui_main.exists():
+        print("TUI entry point not found. Run  c3 --help  for commands.")
+        return
+    env = os.environ.copy()
+    existing_pp = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = str(pkg_root) + (os.pathsep + existing_pp if existing_pp else "")
+    try:
+        subprocess.run([sys.executable, str(tui_main)], env=env)
+    except KeyboardInterrupt:
+        pass
+
+
 def main():
     try:
         from services import error_reporting
@@ -6353,7 +6556,8 @@ def main():
     args = parser.parse_args()
 
     if not args.command:
-        parser.print_help()
+        # Bare `c3` launches the interactive TUI (replaces the old c3.bat wrapper).
+        _launch_tui()
         return
 
     commands = {
@@ -6382,6 +6586,7 @@ def main():
         "hub": cmd_hub,
         "bitbucket": cmd_bitbucket,
         "oracle": cmd_oracle,
+        "upgrade": cmd_upgrade,
     }
 
     cmd_func = commands.get(args.command)

cli/commands/common.py

@@ -200,13 +200,9 @@ def cmd_claudemd(args, deps: CommandDeps):
             print(content)
         else:
             output_path = Path(project_path) / instructions_file
-            output_path.parent.mkdir(parents=True, exist_ok=True)
-            if output_path.exists():
-                existing = output_path.read_text(encoding="utf-8", errors="replace")
-                if "# User Notes" in existing:
-                    user_section = existing[existing.index("# User Notes"):]
-                    content += f"\n\n{user_section}"
-            output_path.write_text(content, encoding="utf-8")
+            # Wrap in the C3 managed block; preserve user content outside it.
+            from services.claude_md import write_c3_instruction_doc
+            write_c3_instruction_doc(output_path, content)
             print(f"{instructions_file} saved to {output_path} ({tokens} tokens)")
 
     elif args.claudemd_cmd == "check":

cli/commands/parser.py

@@ -23,6 +23,10 @@ def build_parser(version: str, parse_cli_ide_arg):
     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")
 
+    p_upgrade = subparsers.add_parser("upgrade", help="Upgrade C3 to the latest PyPI release")
+    p_upgrade.add_argument("--check", action="store_true",
+                           help="Only report whether a newer version exists; don't install")
+
     p_index = subparsers.add_parser("index", help="Rebuild code index")
     p_index.add_argument("--max-files", type=int, default=500)