code-context-control 2.39.1__tar.gz → 2.41.0__tar.gz

{code_context_control-2.39.1/code_context_control.egg-info → code_context_control-2.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.39.1
+Version: 2.41.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -283,9 +283,12 @@ Access Token. Tokens live in the **OS keyring** (Windows Credential Manager,
 macOS Keychain, Linux Secret Service) — never in `.c3/config.json`.
 
 ```bash
-# One-time login per server
+# One-time login per server (stored under this project's .c3/config.json)
 c3 bitbucket login --url https://bitbucket.example.com
-#  → prompts for username + PAT (masked)
+#  -> prompts for username + PAT (masked)
+
+# ...or store it globally so every C3 project can use it
+c3 bitbucket login --global --url https://bitbucket.example.com
 
 # Pin defaults so subsequent calls don't need project/repo
 c3 bitbucket set-default --project PROJ --repo my-service
@@ -294,6 +297,16 @@ c3 bitbucket set-default --project PROJ --repo my-service
 c3 bitbucket status
 ```
 
+**Account resolution precedence:** the project's `.c3/config.json` wins, but when
+it has no active account C3 falls back to the global `~/.c3/config.json`. So a
+single `login --global` (or any login done from your home directory) is reusable
+across every C3 project — the PAT always lives in the OS keyring, never on disk.
+
+> **Upgrading:** stop the running `c3-mcp` server / CLI before `c3 upgrade`. A live
+> process can hold package files open, leaving pip's `~`-prefixed backup dirs
+> (`~ervices`, `~ools`, …) in `site-packages`; those are inert and safe to delete
+> after the upgrade completes.
+
 The MCP tool dispatches by `action`. Read-only actions: `status`, `whoami`,
 `list_projects`, `list_repos`, `get_repo`, `list_prs`, `get_pr`, `get_pr_diff`,
 `get_pr_activities`, `list_branches`, `list_commits`, `list_activity`,

{code_context_control-2.39.1 → code_context_control-2.41.0}/README.md

@@ -221,9 +221,12 @@ Access Token. Tokens live in the **OS keyring** (Windows Credential Manager,
 macOS Keychain, Linux Secret Service) — never in `.c3/config.json`.
 
 ```bash
-# One-time login per server
+# One-time login per server (stored under this project's .c3/config.json)
 c3 bitbucket login --url https://bitbucket.example.com
-#  → prompts for username + PAT (masked)
+#  -> prompts for username + PAT (masked)
+
+# ...or store it globally so every C3 project can use it
+c3 bitbucket login --global --url https://bitbucket.example.com
 
 # Pin defaults so subsequent calls don't need project/repo
 c3 bitbucket set-default --project PROJ --repo my-service
@@ -232,6 +235,16 @@ c3 bitbucket set-default --project PROJ --repo my-service
 c3 bitbucket status
 ```
 
+**Account resolution precedence:** the project's `.c3/config.json` wins, but when
+it has no active account C3 falls back to the global `~/.c3/config.json`. So a
+single `login --global` (or any login done from your home directory) is reusable
+across every C3 project — the PAT always lives in the OS keyring, never on disk.
+
+> **Upgrading:** stop the running `c3-mcp` server / CLI before `c3 upgrade`. A live
+> process can hold package files open, leaving pip's `~`-prefixed backup dirs
+> (`~ervices`, `~ools`, …) in `site-packages`; those are inert and safe to delete
+> after the upgrade completes.
+
 The MCP tool dispatches by `action`. Read-only actions: `status`, `whoami`,
 `list_projects`, `list_repos`, `get_repo`, `list_prs`, `get_pr`, `get_pr_diff`,
 `get_pr_activities`, `list_branches`, `list_commits`, `list_activity`,

{code_context_control-2.39.1 → code_context_control-2.41.0}/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.39.0"
+__version__ = "2.41.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -5577,14 +5577,19 @@ def _bb_cmd_login(args, project_path: str) -> None:
     from services import bitbucket_credentials as bb_creds
     from services.bitbucket_client import BitbucketDataCenterClient, BitbucketError
 
+    # --global stores the account in ~/.c3/config.json so it is reusable in
+    # every C3 project (load_bitbucket_config falls back to it automatically).
+    if getattr(args, "use_global", False):
+        project_path = str(Path.home())
+
     base_url = (args.url or "").rstrip("/")
     username = args.username or input(f"Username for {base_url}: ").strip()
     if not username:
-        print("Login cancelled — username required.")
+        print("Login cancelled -- username required.")
         return
     token = args.token or getpass.getpass(f"Personal Access Token for {username}: ").strip()
     if not token:
-        print("Login cancelled — token required.")
+        print("Login cancelled -- token required.")
         return
 
     try:
@@ -5600,10 +5605,13 @@ def _bb_cmd_login(args, project_path: str) -> None:
     if getattr(args, "insecure", False):
         bb_creds.set_verify_tls(False, project_path=project_path)
 
-    print(f"[OK] Stored credentials for {username}@{base_url}")
+    scope = "global (~/.c3)" if getattr(args, "use_global", False) else "project"
+    print(f"[OK] Stored credentials for {username}@{base_url} [{scope}]")
 
-    # Connection probe — non-fatal if it fails (token might be valid but
-    # network blocked at this moment).
+    # Connection probe -- non-fatal if it fails (token might be valid but the
+    # network is blocked right now). Gate success on application-properties
+    # only; whoami enrichment is best-effort so a valid login never prints a
+    # failure (Bitbucket DC has no /users/me).
     try:
         client = BitbucketDataCenterClient(
             base_url=base_url, token=token,
@@ -5611,12 +5619,20 @@ def _bb_cmd_login(args, project_path: str) -> None:
         )
         props = client.application_properties()
         version = props.get("version", "?")
-        user = client.whoami()
         print(f"     Server: {version} ({base_url})")
-        print(f"     Auth as: {user.get('displayName', username)} <{user.get('emailAddress', '?')}>")
     except BitbucketError as exc:
         print(f"[warn] Connection probe failed: {exc}")
-        print("       Token saved anyway — re-test with `c3 bitbucket status`.")
+        print("       Token saved anyway -- re-test with `c3 bitbucket status`.")
+        return
+    try:
+        user = client.whoami()
+        if user:
+            print(
+                f"     Auth as: {user.get('displayName', username)} "
+                f"<{user.get('emailAddress', '?')}>"
+            )
+    except BitbucketError:
+        pass
 
 
 def _bb_cmd_logout(args, project_path: str) -> None:
@@ -5661,7 +5677,7 @@ def _bb_cmd_status(args, project_path: str) -> None:
         return
     token = bb_creds.load_token(active["base_url"], active["username"])
     if not token:
-        print("  Connection: FAIL — no token in keyring")
+        print("  Connection: FAIL -- no token in keyring")
         return
     try:
         client = BitbucketDataCenterClient(
@@ -5671,7 +5687,7 @@ def _bb_cmd_status(args, project_path: str) -> None:
         props = client.application_properties()
         print(f"  Connection: OK (version {props.get('version','?')})")
     except BitbucketError as exc:
-        print(f"  Connection: FAIL — {exc}")
+        print(f"  Connection: FAIL -- {exc}")
 
 
 def _bb_cmd_use(args, project_path: str) -> None:
@@ -6571,6 +6587,15 @@ def _launch_tui() -> None:
 
 
 def main():
+    # Force UTF-8 on the CLI streams so server-supplied text (PR titles, branch
+    # names, diffs) and our own glyphs render cleanly on Windows cp1252 consoles
+    # instead of raising UnicodeEncodeError or mojibaking.
+    for _stream in (sys.stdout, sys.stderr):
+        try:
+            _stream.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
     try:
         from services import error_reporting
         error_reporting.init(component="c3-cli", version=__version__)

{code_context_control-2.39.1 → code_context_control-2.41.0}/cli/commands/parser.py

@@ -303,6 +303,7 @@ def build_parser(version: str, parse_cli_ide_arg):
     bb_login.add_argument("--token", help="Personal Access Token (prompted via getpass if omitted — preferred)")
     bb_login.add_argument("--no-set-active", action="store_true", help="Do not switch the active account to this one")
     bb_login.add_argument("--insecure", action="store_true", help="Disable TLS verification (self-signed certs)")
+    bb_login.add_argument("--global", dest="use_global", action="store_true", help="Store the account in the global ~/.c3/config.json so it is reusable in every C3 project")
     bb_login.add_argument("project_path", nargs="?", default=".")
 
     bb_logout = bb_subs.add_parser("logout", help="Remove a Bitbucket account from keyring + config")

{code_context_control-2.39.1 → code_context_control-2.41.0}/cli/tools/bitbucket.py

@@ -50,7 +50,12 @@ def _cap(resp: str) -> str:
         candidate = "\n".join(lines) + "\n[truncated]"
         if count_tokens(candidate) <= _RESPONSE_TOKEN_CAP:
             return candidate
-    return "\n".join(lines[:20]) + "\n[truncated]"
+    # A single over-long line never splits above; hard-clamp by characters as a
+    # final guard (~4 chars/token) so one huge line can't blow past the cap.
+    head = "\n".join(lines[:20])
+    if count_tokens(head) > _RESPONSE_TOKEN_CAP:
+        head = head[:_RESPONSE_TOKEN_CAP * 4]
+    return head + "\n[truncated]"
 
 
 def _build_client(svc) -> tuple[BitbucketDataCenterClient | None, str]:
@@ -111,20 +116,20 @@ def _format_pr(pr: dict) -> str:
     author = (pr.get("author") or {}).get("user", {}).get("name", "?")
     src = (pr.get("fromRef") or {}).get("displayId", "?")
     dst = (pr.get("toRef") or {}).get("displayId", "?")
-    return f"  #{pr_id} [{state:7}] {src} → {dst}  by {author}\n         {title}"
+    return f"  #{pr_id} [{state:7}] {src} -> {dst}  by {author}\n         {title}"
 
 
 def _format_pr_full(pr: dict) -> str:
     lines = [
-        f"PR #{pr.get('id')} [{pr.get('state')}] — {pr.get('title','')}",
-        f"  {(pr.get('fromRef') or {}).get('displayId')} → {(pr.get('toRef') or {}).get('displayId')}",
+        f"PR #{pr.get('id')} [{pr.get('state')}] -- {pr.get('title','')}",
+        f"  {(pr.get('fromRef') or {}).get('displayId')} -> {(pr.get('toRef') or {}).get('displayId')}",
         f"  Author: {(pr.get('author') or {}).get('user',{}).get('displayName','?')}",
         f"  Version: {pr.get('version')} | Open tasks: {pr.get('openTaskCount', 0)}",
     ]
     reviewers = pr.get("reviewers") or []
     if reviewers:
         rs = ", ".join(
-            f"{r.get('user',{}).get('name','?')}({'✓' if r.get('approved') else '·'})"
+            f"{r.get('user',{}).get('name','?')}({'[x]' if r.get('approved') else '[ ]'})"
             for r in reviewers
         )
         lines.append(f"  Reviewers: {rs}")
@@ -190,7 +195,7 @@ def _act_status(client: BitbucketDataCenterClient | None, err: str, svc) -> str:
         version = props.get("version", "?")
         out.append(f"  Server : OK (version {version})")
     except BitbucketError as exc:
-        out.append(f"  Server : FAIL — {exc}")
+        out.append(f"  Server : FAIL -- {exc}")
     return "\n".join(out)
 
 
@@ -214,7 +219,7 @@ def _act_list_projects(client: BitbucketDataCenterClient, kwargs: dict) -> str:
     for p in projects[:50]:
         lines.append(f"  {p.get('key','?'):16} {p.get('name','?')}")
     if len(projects) > 50:
-        lines.append(f"  … +{len(projects) - 50} more")
+        lines.append(f"  ... +{len(projects) - 50} more")
     return "\n".join(lines)
 
 
@@ -222,11 +227,11 @@ def _act_list_repos(client: BitbucketDataCenterClient, project: str) -> str:
     repos = client.list_repos(project)
     if not repos:
         return f"[bitbucket:repos] {project}: (none)"
-    lines = [f"[bitbucket:repos] {project} — {len(repos)} repo(s)"]
+    lines = [f"[bitbucket:repos] {project} - {len(repos)} repo(s)"]
     for r in repos[:80]:
         lines.append(f"  {r.get('slug','?'):30} {r.get('name','?')}")
     if len(repos) > 80:
-        lines.append(f"  … +{len(repos) - 80} more")
+        lines.append(f"  ... +{len(repos) - 80} more")
     return "\n".join(lines)
 
 
@@ -252,7 +257,7 @@ def _act_list_prs(client, project: str, repo: str, kwargs: dict) -> str:
     )
     if not prs:
         return f"[bitbucket:prs] {project}/{repo} state={state}: (none)"
-    out = [f"[bitbucket:prs] {project}/{repo} state={state} — {len(prs)} PR(s)"]
+    out = [f"[bitbucket:prs] {project}/{repo} state={state} - {len(prs)} PR(s)"]
     for pr in prs:
         out.append(_format_pr(pr))
     return "\n".join(out)
@@ -266,7 +271,7 @@ def _act_get_pr(client, project: str, repo: str, pr_id: int) -> str:
 def _act_get_pr_diff(client, project: str, repo: str, pr_id: int, kwargs: dict) -> str:
     diff = client.get_pr_diff(project, repo, pr_id, context_lines=int(kwargs.get("context_lines", 3)))
     if len(diff) > _DIFF_PREVIEW_CHARS:
-        diff = diff[:_DIFF_PREVIEW_CHARS] + "\n… [diff truncated]"
+        diff = diff[:_DIFF_PREVIEW_CHARS] + "\n... [diff truncated]"
     return f"[bitbucket:diff] {project}/{repo}#{pr_id}\n{diff}"
 
 
@@ -274,7 +279,7 @@ def _act_get_pr_activities(client, project: str, repo: str, pr_id: int) -> str:
     acts = client.get_pr_activities(project, repo, pr_id)
     if not acts:
         return f"[bitbucket:pr-activity] {project}/{repo}#{pr_id}: (none)"
-    out = [f"[bitbucket:pr-activity] {project}/{repo}#{pr_id} — {len(acts)} event(s)"]
+    out = [f"[bitbucket:pr-activity] {project}/{repo}#{pr_id} - {len(acts)} event(s)"]
     for a in acts[:50]:
         out.append(_format_activity(a))
     return "\n".join(out)
@@ -341,11 +346,11 @@ def _act_list_branches(client, project: str, repo: str, kwargs: dict) -> str:
     branches = client.list_branches(project, repo, filter_text=kwargs.get("filter", ""))
     if not branches:
         return f"[bitbucket:branches] {project}/{repo}: (none)"
-    out = [f"[bitbucket:branches] {project}/{repo} — {len(branches)} branch(es)"]
+    out = [f"[bitbucket:branches] {project}/{repo} - {len(branches)} branch(es)"]
     for b in branches[:80]:
         out.append(_format_branch(b))
     if len(branches) > 80:
-        out.append(f"  … +{len(branches) - 80} more")
+        out.append(f"  ... +{len(branches) - 80} more")
     return "\n".join(out)
 
 
@@ -378,7 +383,7 @@ def _act_list_commits(client, project: str, repo: str, kwargs: dict) -> str:
     )
     if not commits:
         return f"[bitbucket:commits] {project}/{repo}: (none)"
-    out = [f"[bitbucket:commits] {project}/{repo} — {len(commits)} commit(s)"]
+    out = [f"[bitbucket:commits] {project}/{repo} - {len(commits)} commit(s)"]
     for c in commits:
         out.append(_format_commit(c))
     return "\n".join(out)
@@ -388,7 +393,7 @@ def _act_list_activity(client, project: str, repo: str, kwargs: dict) -> str:
     acts = client.list_repo_activities(project, repo, limit=int(kwargs.get("limit", 30)))
     if not acts:
         return f"[bitbucket:activity] {project}/{repo}: (none)"
-    out = [f"[bitbucket:activity] {project}/{repo} — {len(acts)} event(s)"]
+    out = [f"[bitbucket:activity] {project}/{repo} - {len(acts)} event(s)"]
     for a in acts:
         out.append(_format_commit(a))
     return "\n".join(out)
@@ -401,7 +406,7 @@ def _act_build_status(client, kwargs: dict) -> str:
     builds = client.get_build_status(commit)
     if not builds:
         return f"[bitbucket:build_status] {commit[:12]}: (none)"
-    out = [f"[bitbucket:build_status] {commit[:12]} — {len(builds)} build(s)"]
+    out = [f"[bitbucket:build_status] {commit[:12]} - {len(builds)} build(s)"]
     for b in builds:
         out.append(_format_build(b))
     return "\n".join(out)
@@ -429,10 +434,10 @@ def _act_list_webhooks(client, project: str, repo: str) -> str:
     hooks = client.list_webhooks(project, repo)
     if not hooks:
         return f"[bitbucket:webhooks] {project}/{repo}: (none)"
-    out = [f"[bitbucket:webhooks] {project}/{repo} — {len(hooks)} hook(s)"]
+    out = [f"[bitbucket:webhooks] {project}/{repo} - {len(hooks)} hook(s)"]
     for h in hooks:
         out.append(
-            f"  #{h.get('id')} [{'on' if h.get('active') else 'off'}] {h.get('name','?')} → {h.get('url','?')}"
+            f"  #{h.get('id')} [{'on' if h.get('active') else 'off'}] {h.get('name','?')} -> {h.get('url','?')}"
         )
         evs = h.get("events") or []
         if evs:
@@ -454,7 +459,7 @@ def _act_create_webhook(client, project: str, repo: str, kwargs: dict) -> str:
         active=bool(kwargs.get("active", True)),
         secret=kwargs.get("secret", ""),
     )
-    return f"[bitbucket:webhook-created] {project}/{repo} #{res.get('id','?')} {name} → {url}"
+    return f"[bitbucket:webhook-created] {project}/{repo} #{res.get('id','?')} {name} -> {url}"
 
 
 def _act_delete_webhook(client, project: str, repo: str, kwargs: dict) -> str:

{code_context_control-2.39.1 → code_context_control-2.41.0}/cli/tools/shell.py

@@ -4,12 +4,21 @@ Wraps subprocess.Popen with the Windows-safe pattern from
 services/edit_ledger.py::_git_combined (Popen + taskkill /F /T + stdin=DEVNULL).
 Auto-filters long stdout via handle_filter, auto-logs git mutations
 to the edit ledger, and accounts stdout tokens against session budget.
+
+Shell selection: on Windows, commands are run through Git Bash (bash.exe) when
+it is available, so c3_shell speaks the same POSIX dialect as the native Bash
+tool (forward-slash paths, single quotes, `$VAR`, ls/grep/cat, heredocs). This
+avoids the cmd.exe/POSIX mismatch that forced callers to fall back to native
+Bash for bash-flavored commands. Set C3_SHELL_BASH=0 to force cmd.exe, or point
+C3_SHELL_BASH at a specific bash.exe to override discovery. POSIX platforms are
+unchanged (shell=True → /bin/sh).
 """
 from __future__ import annotations
 
 import asyncio
 import os
 import re
+import shutil
 import subprocess
 import sys
 import time
@@ -59,6 +68,58 @@ _MAX_TIMEOUT = 600
 _FILTER_THRESHOLD_LINES = 30
 
 
+# Cache for discovered Git Bash path: [] = uncomputed, [None]/[path] = computed.
+_bash_cache: list = []
+
+
+def _discover_git_bash() -> str | None:
+    """Locate a Git-for-Windows bash.exe, never WSL/System32 bash.
+
+    WSL's bash runs in a Linux subsystem with /mnt/c paths, which would break
+    the Windows `cwd` semantics every caller relies on — so it is rejected.
+    """
+    candidates: list[str] = []
+    for base_env in ("ProgramW6432", "ProgramFiles", "ProgramFiles(x86)"):
+        base = os.environ.get(base_env)
+        if base:
+            candidates.append(os.path.join(base, "Git", "bin", "bash.exe"))
+            candidates.append(os.path.join(base, "Git", "usr", "bin", "bash.exe"))
+    candidates.append(r"C:\Program Files\Git\bin\bash.exe")
+    candidates.append(r"C:\Program Files\Git\usr\bin\bash.exe")
+    for path in candidates:
+        if os.path.isfile(path):
+            return path
+    # Last resort: PATH lookup, but reject WSL/Store bash (System32/WindowsApps).
+    found = shutil.which("bash")
+    if found:
+        low = found.lower()
+        if "system32" not in low and "windowsapps" not in low:
+            return found
+    return None
+
+
+def _select_bash() -> str | None:
+    """Return the bash.exe to run commands through on Windows, else None.
+
+    None means "use the platform default shell" (cmd.exe on Windows via
+    shell=True, /bin/sh on POSIX). Honors the C3_SHELL_BASH override:
+    '0'/'cmd' forces the platform default; an existing file path forces that
+    bash. Discovery is cached after the first call.
+    """
+    if sys.platform != "win32":
+        return None
+    override = os.environ.get("C3_SHELL_BASH")
+    if override is not None:
+        if override.strip().lower() in ("0", "", "cmd", "false", "off"):
+            return None
+        if os.path.isfile(override):
+            return override
+        # Unrecognized override → fall through to discovery.
+    if not _bash_cache:
+        _bash_cache.append(_discover_git_bash())
+    return _bash_cache[0]
+
+
 def _popen_kwargs() -> dict:
     # Force UTF-8 in child processes so Unicode output (→, box-drawing, emoji)
     # doesn't crash on Windows' legacy cp1252 console encoding. setdefault so an
@@ -89,8 +150,17 @@ def _kill_tree(proc: subprocess.Popen) -> None:
 def _run_sync(cmd: str, cwd: str, timeout: int) -> dict:
     """Blocking subprocess run with hard kill on timeout. Returns structured dict."""
     start = time.time()
+    bash = _select_bash()
+    if bash:
+        # POSIX dialect via Git Bash — matches the native Bash tool.
+        popen_target: object = [bash, "-c", cmd]
+        use_shell = False
+    else:
+        # Platform default: cmd.exe on Windows, /bin/sh on POSIX.
+        popen_target = cmd
+        use_shell = True
     proc = subprocess.Popen(
-        cmd, shell=True, cwd=cwd,
+        popen_target, shell=use_shell, cwd=cwd,
         stdout=subprocess.PIPE, stderr=subprocess.PIPE,
         text=True, encoding="utf-8", errors="replace",
         **_popen_kwargs(),

{code_context_control-2.39.1 → code_context_control-2.41.0/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.39.1
+Version: 2.41.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -283,9 +283,12 @@ Access Token. Tokens live in the **OS keyring** (Windows Credential Manager,
 macOS Keychain, Linux Secret Service) — never in `.c3/config.json`.
 
 ```bash
-# One-time login per server
+# One-time login per server (stored under this project's .c3/config.json)
 c3 bitbucket login --url https://bitbucket.example.com
-#  → prompts for username + PAT (masked)
+#  -> prompts for username + PAT (masked)
+
+# ...or store it globally so every C3 project can use it
+c3 bitbucket login --global --url https://bitbucket.example.com
 
 # Pin defaults so subsequent calls don't need project/repo
 c3 bitbucket set-default --project PROJ --repo my-service
@@ -294,6 +297,16 @@ c3 bitbucket set-default --project PROJ --repo my-service
 c3 bitbucket status
 ```
 
+**Account resolution precedence:** the project's `.c3/config.json` wins, but when
+it has no active account C3 falls back to the global `~/.c3/config.json`. So a
+single `login --global` (or any login done from your home directory) is reusable
+across every C3 project — the PAT always lives in the OS keyring, never on disk.
+
+> **Upgrading:** stop the running `c3-mcp` server / CLI before `c3 upgrade`. A live
+> process can hold package files open, leaving pip's `~`-prefixed backup dirs
+> (`~ervices`, `~ools`, …) in `site-packages`; those are inert and safe to delete
+> after the upgrade completes.
+
 The MCP tool dispatches by `action`. Read-only actions: `status`, `whoami`,
 `list_projects`, `list_repos`, `get_repo`, `list_prs`, `get_pr`, `get_pr_diff`,
 `get_pr_activities`, `list_branches`, `list_commits`, `list_activity`,

{code_context_control-2.39.1 → code_context_control-2.41.0}/code_context_control.egg-info/SOURCES.txt

@@ -159,6 +159,7 @@ tests/test_activity_reporter.py
 tests/test_aider_polyglot.py
 tests/test_bitbucket_cli_smoke.py
 tests/test_bitbucket_client.py
+tests/test_bitbucket_config_fallback.py
 tests/test_bitbucket_credentials.py
 tests/test_bitbucket_tool.py
 tests/test_c3_shell.py

{code_context_control-2.39.1 → code_context_control-2.41.0}/core/config.py

@@ -290,15 +290,41 @@ BITBUCKET_DEFAULTS = {
 }
 
 
+def _read_bitbucket_section(config_file: Path) -> dict:
+    """Return the ``bitbucket`` section of a config file, or ``{}``."""
+    if not config_file.exists():
+        return {}
+    try:
+        with open(config_file, encoding="utf-8") as f:
+            data = json.load(f)
+    except Exception:
+        return {}
+    section = data.get("bitbucket", {})
+    return section if isinstance(section, dict) else {}
+
+
 def load_bitbucket_config(project_path: str) -> dict:
-    """Load Bitbucket config from .c3/config.json, merged with defaults."""
-    config_file = Path(project_path) / ".c3" / "config.json"
-    overrides = {}
-    if config_file.exists():
+    """Load Bitbucket config from .c3/config.json, merged with defaults.
+
+    Resolution precedence: the project ``<project>/.c3/config.json`` wins, but
+    when it has no active account we fall back to the global
+    ``~/.c3/config.json`` so a one-time ``c3 bitbucket login`` (or
+    ``login --global``) is reusable across every C3 project. The PAT itself
+    always lives in the OS keyring, never in these files.
+    """
+    project_file = Path(project_path) / ".c3" / "config.json"
+    overrides = _read_bitbucket_section(project_file)
+    if not (overrides.get("active") or {}).get("base_url"):
+        # Path.home() raises RuntimeError when no home dir is resolvable (e.g.
+        # a stripped subprocess env); treat that as "no global fallback".
         try:
-            with open(config_file, encoding="utf-8") as f:
-                data = json.load(f)
-            overrides = data.get("bitbucket", {})
+            home_file = Path.home() / ".c3" / "config.json"
+            already_home = home_file.resolve() == project_file.resolve()
         except Exception:
-            pass
+            home_file = None
+            already_home = True
+        if home_file is not None and not already_home:
+            home_overrides = _read_bitbucket_section(home_file)
+            if (home_overrides.get("active") or {}).get("base_url"):
+                overrides = home_overrides
     return {**BITBUCKET_DEFAULTS, **overrides}

{code_context_control-2.39.1 → code_context_control-2.41.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.39.1"
+version = "2.41.0"
 description = "Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.39.1 → code_context_control-2.41.0}/services/bitbucket_client.py

@@ -28,7 +28,15 @@ _TIMEOUT = 30  # seconds
 _API = "/rest/api/1.0"
 _BUILD_API = "/rest/build-status/1.0"
 _BRANCH_UTILS = "/rest/branch-utils/1.0"
-_USER_AGENT = "c3-bitbucket/2.30.0"
+
+try:
+    from importlib.metadata import version as _pkg_version
+
+    _C3_VERSION = _pkg_version("code-context-control")
+except Exception:  # pragma: no cover - package metadata may be unavailable
+    _C3_VERSION = "0.0.0"
+
+_USER_AGENT = f"c3-bitbucket/{_C3_VERSION}"
 
 
 class BitbucketError(RuntimeError):
@@ -80,6 +88,8 @@ class BitbucketDataCenterClient:
         params: dict | None = None,
         api_root: str = _API,
         raw: bool = False,
+        accept: str = "application/json",
+        return_headers: bool = False,
     ) -> Any:
         full_path = f"{api_root}{path}"
         if params:
@@ -92,7 +102,7 @@ class BitbucketDataCenterClient:
 
         headers = {
             "Authorization": f"Bearer {self._token}",
-            "Accept": "application/json",
+            "Accept": accept,
             "User-Agent": _USER_AGENT,
         }
         data: bytes | None = None
@@ -109,14 +119,19 @@ class BitbucketDataCenterClient:
         try:
             with urllib.request.urlopen(req, timeout=self._timeout, context=self._ssl_context()) as resp:
                 payload = resp.read()
+                resp_headers = {k: v for k, v in resp.headers.items()}
                 if raw:
-                    return payload
-                if not payload:
-                    return {}
-                try:
-                    return json.loads(payload.decode("utf-8"))
-                except json.JSONDecodeError:
-                    return {"raw": payload.decode("utf-8", errors="replace")}
+                    body_out: Any = payload
+                elif not payload:
+                    body_out = {}
+                else:
+                    try:
+                        body_out = json.loads(payload.decode("utf-8"))
+                    except json.JSONDecodeError:
+                        body_out = {"raw": payload.decode("utf-8", errors="replace")}
+                if return_headers:
+                    return body_out, resp_headers
+                return body_out
         except urllib.error.HTTPError as exc:
             try:
                 err_payload = json.loads(exc.read().decode("utf-8"))
@@ -168,8 +183,27 @@ class BitbucketDataCenterClient:
         return self._request("GET", "/application-properties")
 
     def whoami(self) -> dict:
-        """The authenticated user (PAT owner)."""
-        return self._request("GET", "/users/me")
+        """The authenticated user (PAT owner).
+
+        Bitbucket Data Center / Server has no ``/users/me`` endpoint (that is a
+        Cloud convention; DC treats ``me`` as a literal username and 404s).
+        Resolve the account from the ``X-AUSERNAME`` header that rides on every
+        authenticated response, then enrich with the user record when possible.
+        """
+        _body, headers = self._request(
+            "GET", "/application-properties", return_headers=True
+        )
+        slug = ""
+        for key, value in (headers or {}).items():
+            if key.lower() == "x-ausername":
+                slug = urllib.parse.unquote(value or "")
+                break
+        if not slug:
+            return {}
+        try:
+            return self._request("GET", f"/users/{urllib.parse.quote(slug)}")
+        except BitbucketError:
+            return {"name": slug, "slug": slug, "displayName": slug}
 
     # ── Projects & repos (read) ───────────────────────────
 
@@ -282,6 +316,7 @@ class BitbucketDataCenterClient:
             f"/projects/{project_key}/repos/{repo_slug}/pull-requests/{pr_id}/diff",
             params={"contextLines": context_lines},
             raw=True,
+            accept="text/plain",
         )
         if isinstance(payload, bytes):
             return payload.decode("utf-8", errors="replace")