entelligence-cli 0.1.78__tar.gz → 0.1.80__tar.gz

{entelligence_cli-0.1.78 → entelligence_cli-0.1.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entelligence-cli
-Version: 0.1.78
+Version: 0.1.80
 Summary: AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes
 Author-email: EntelligenceAI <info@entelligence.ai>
 Project-URL: Homepage, https://entelligence.ai

{entelligence_cli-0.1.78 → entelligence_cli-0.1.80}/entelligence_cli/router/claude_settings.py

@@ -62,6 +62,76 @@ def _write_settings(path: Path, settings: dict[str, Any]) -> None:
     tmp.replace(path)
 
 
+# The UserPromptSubmit hook that stamps every main CC turn with the process's
+# CLAUDE_CODE_SESSION_ID. The backend extracts this from the system prompt and
+# uses it as the session key, giving every turn in a conversation — including
+# subagents that inherit the same env var — a stable, reliable session ID in DB
+# rows instead of a hash that breaks on background tasks or multi-session users.
+_SESSION_HOOK_COMMAND = (
+    'printf "{\\"hookSpecificOutput\\": {\\"hookEventName\\": \\"UserPromptSubmit\\",'
+    ' \\"additionalContext\\": \\"x-cc-session-id: $CLAUDE_CODE_SESSION_ID\\"}}"'
+)
+
+# Previous command form (single-quoted — variable never expanded). Kept so
+# _remove_session_hook can clean it up on `router off` for users who ran an
+# older version of the CLI before the double-quote fix.
+_SESSION_HOOK_COMMAND_LEGACY = (
+    "printf"
+    ' \'{"hookSpecificOutput": {"hookEventName": "UserPromptSubmit",'
+    ' "additionalContext": "x-cc-session-id: $CLAUDE_CODE_SESSION_ID"}}\''
+)
+
+_SESSION_HOOK_COMMANDS = {_SESSION_HOOK_COMMAND, _SESSION_HOOK_COMMAND_LEGACY}
+
+
+def _has_session_hook(settings: dict[str, Any]) -> bool:
+    """True when our exact UserPromptSubmit hook command is already present."""
+    for entry in settings.get("hooks", {}).get("UserPromptSubmit", []):
+        for h in entry.get("hooks", []):
+            if h.get("command") == _SESSION_HOOK_COMMAND:
+                return True
+    return False
+
+
+def _install_session_hook(settings: dict[str, Any], path: Path, backup: dict[str, Any]) -> None:
+    """Add the UserPromptSubmit hook that injects CLAUDE_CODE_SESSION_ID.
+
+    Idempotent — no-op when our exact hook command is already present. Records
+    in the backup whether WE added it so ``unwire`` can remove it without
+    touching any hook the user had beforehand.
+    """
+    if _has_session_hook(settings):
+        return
+    hooks = settings.setdefault("hooks", {})
+    hooks.setdefault("UserPromptSubmit", []).append(
+        {
+            "matcher": "",
+            "hooks": [{"type": "command", "command": _SESSION_HOOK_COMMAND}],
+        }
+    )
+    backup.setdefault(str(path), {})["installed_session_hook"] = True
+
+
+def _remove_session_hook(settings: dict[str, Any]) -> None:
+    """Remove the session hook we installed (called by unwire when backup says we added it).
+
+    Matches against all known command forms so legacy installs (single-quoted
+    version that never expanded the variable) are cleaned up too.
+    """
+    ups = settings.get("hooks", {}).get("UserPromptSubmit", [])
+    filtered = [
+        entry
+        for entry in ups
+        if not any(h.get("command") in _SESSION_HOOK_COMMANDS for h in entry.get("hooks", []))
+    ]
+    if filtered:
+        settings["hooks"]["UserPromptSubmit"] = filtered
+    else:
+        settings.get("hooks", {}).pop("UserPromptSubmit", None)
+    if not settings.get("hooks"):
+        settings.pop("hooks", None)
+
+
 def base_url(port: int) -> str:
     """The ANTHROPIC_BASE_URL value pointing at the local router."""
     return f"http://127.0.0.1:{port}"
@@ -105,25 +175,31 @@ def wire_hosted(scope: str, base: str, token: str) -> None:
     path = settings_path(scope)
     settings = _read_settings(path)
     env = settings.setdefault("env", {})
+
+    backup = load_backup()
+    entry = backup.get(str(path))
     if env.get("ANTHROPIC_BASE_URL") != base:
-        backup = load_backup()
-        entry = backup.get(str(path))
         if entry is None:
             # First time we touch this path: capture BOTH baselines.
             backup[str(path)] = {
                 "ANTHROPIC_BASE_URL": env.get("ANTHROPIC_BASE_URL"),
                 "ANTHROPIC_AUTH_TOKEN": env.get("ANTHROPIC_AUTH_TOKEN"),
             }
-            save_backup(backup)
         elif "ANTHROPIC_AUTH_TOKEN" not in entry:
             # A prior LOCAL `wire` captured only the base URL (it never sets a token).
             # Record the token baseline now — the current value is still the genuine
             # pre-router one — so `unwire` knows to clear/restore it. Without this the
             # Entelligence auth token is left in settings.json after `router off`.
             entry["ANTHROPIC_AUTH_TOKEN"] = env.get("ANTHROPIC_AUTH_TOKEN")
-            save_backup(backup)
+
     env["ANTHROPIC_BASE_URL"] = base
     env["ANTHROPIC_AUTH_TOKEN"] = token
+
+    # Install the UserPromptSubmit hook so every main turn carries
+    # CLAUDE_CODE_SESSION_ID — backend uses it as the session key in DB rows.
+    _install_session_hook(settings, path, backup)
+
+    save_backup(backup)
     _write_settings(path, settings)
 
 
@@ -143,14 +219,18 @@ def wire(scope: str, port: int) -> None:
 
     previous = env.get("ANTHROPIC_BASE_URL")
     ours = base_url(port)
-    if previous != ours:
-        backup = load_backup()
+    backup = load_backup()
+    if previous != ours and str(path) not in backup:
         # Only capture a backup once: re-running `on` must not overwrite the
         # genuine pre-router value with our own URL from a stale state.
-        if str(path) not in backup:
-            backup[str(path)] = {"ANTHROPIC_BASE_URL": previous}
-            save_backup(backup)
+        backup[str(path)] = {"ANTHROPIC_BASE_URL": previous}
     env["ANTHROPIC_BASE_URL"] = ours
+
+    # Install the UserPromptSubmit hook so every main turn carries
+    # CLAUDE_CODE_SESSION_ID — backend uses it as the session key in DB rows.
+    _install_session_hook(settings, path, backup)
+
+    save_backup(backup)
     _write_settings(path, settings)
 
 
@@ -190,6 +270,10 @@ def unwire(scope: str) -> bool:
             env.pop("ANTHROPIC_AUTH_TOKEN", None)
     if not env:
         settings.pop("env", None)
+    # Remove the session hook only if we installed it — leave any pre-existing
+    # user hook alone (backup records installed_session_hook=True only when we added it).
+    if saved.get("installed_session_hook"):
+        _remove_session_hook(settings)
     # Persist settings FIRST, then drop the backup entry — so if the settings write
     # fails (permissions/disk), the backup is still intact for a retry rather than
     # consumed against a file that still points at the router.

{entelligence_cli-0.1.78 → entelligence_cli-0.1.80}/entelligence_cli/upload/discovery.py

@@ -49,7 +49,10 @@ def _is_claude_code_sidechain(head: bytes) -> bool:
             continue
         try:
             obj = json.loads(raw)
-        except json.JSONDecodeError:
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            # UnicodeDecodeError: the fixed-size head can slice a multi-byte UTF-8 char at the
+            # boundary (or a line carries invalid bytes) — json.loads decodes bytes and raises it,
+            # not JSONDecodeError. Skip the line instead of crashing the whole discovery walk.
             continue
         if obj.get("isSidechain") is True:
             return True
@@ -67,7 +70,10 @@ def _cc_cwd_from_head(head: bytes) -> Path | None:
             continue
         try:
             obj = json.loads(raw)
-        except json.JSONDecodeError:
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            # UnicodeDecodeError: the fixed-size head can slice a multi-byte UTF-8 char at the
+            # boundary (or a line carries invalid bytes) — json.loads decodes bytes and raises it,
+            # not JSONDecodeError. Skip the line instead of crashing the whole discovery walk.
             continue
         cwd = obj.get("cwd")
         if isinstance(cwd, str) and cwd:
@@ -153,7 +159,10 @@ def _codex_cwd_from_head(head: bytes) -> Path | None:
             continue
         try:
             obj = json.loads(raw)
-        except json.JSONDecodeError:
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            # UnicodeDecodeError: the fixed-size head can slice a multi-byte UTF-8 char at the
+            # boundary (or a line carries invalid bytes) — json.loads decodes bytes and raises it,
+            # not JSONDecodeError. Skip the line instead of crashing the whole discovery walk.
             continue
         if obj.get("type") == "session_meta":
             cwd = (obj.get("payload") or {}).get("cwd")

{entelligence_cli-0.1.78 → entelligence_cli-0.1.80}/entelligence_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entelligence-cli
-Version: 0.1.78
+Version: 0.1.80
 Summary: AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes
 Author-email: EntelligenceAI <info@entelligence.ai>
 Project-URL: Homepage, https://entelligence.ai

{entelligence_cli-0.1.78 → entelligence_cli-0.1.80}/entelligence_cli.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ entelligence_cli/upload/stores.py
 tests/test_attach_fix_smoke.py
 tests/test_attach_ticket_smoke.py
 tests/test_conductor.py
+tests/test_discovery_head_unicode.py
 tests/test_discovery_opencode.py
 tests/test_incident_smoke.py
 tests/test_pii.py

{entelligence_cli-0.1.78 → entelligence_cli-0.1.80}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "entelligence-cli"
-version = "0.1.78"
+version = "0.1.80"
 description = "AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes"
 readme = "README.md"
 authors = [

entelligence_cli-0.1.80/tests/test_discovery_head_unicode.py

@@ -0,0 +1,34 @@
+"""Regression: a transcript head with a sliced/invalid multi-byte UTF-8 char must not crash
+discovery. The fixed-size head read (JSONL_HEAD_BYTES) can cut a multi-byte char at the boundary;
+json.loads decodes the bytes and raises UnicodeDecodeError (not JSONDecodeError), which previously
+propagated out of the whole `insights sync --transcripts` walk."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from entelligence_cli.upload.discovery import (
+    _cc_cwd_from_head,
+    _codex_cwd_from_head,
+    _is_claude_code_sidechain,
+)
+
+
+# A line whose bytes end mid 3-byte char (0xe2 0x98 = 2 of 3) -> UnicodeDecodeError on json.loads.
+_TRUNCATED = b'{"x":"\xe2\x98'
+
+
+def test_sidechain_check_skips_undecodable_line():
+    head = _TRUNCATED + b'\n{"type":"user","sessionId":"s","cwd":"/tmp/p"}'
+    # Must not raise; the bad first line is skipped, the user line decides it's not a sidechain.
+    assert _is_claude_code_sidechain(head) is False
+
+
+def test_cc_cwd_skips_undecodable_line():
+    head = _TRUNCATED + b'\n{"type":"user","cwd":"/tmp/proj"}'
+    assert _cc_cwd_from_head(head) == Path("/tmp/proj")
+
+
+def test_codex_cwd_skips_undecodable_line():
+    head = _TRUNCATED + b'\n{"type":"session_meta","payload":{"cwd":"/tmp/cx"}}'
+    assert _codex_cwd_from_head(head) == Path("/tmp/cx")