claude-smart 0.2.28 → 0.2.29

package/plugin/src/claude_smart/cli.py

@@ -69,6 +69,8 @@ _DASHBOARD_DIR = _PLUGIN_ROOT / "dashboard"
 _BACKEND_SCRIPT = _SCRIPTS_DIR / "backend-service.sh"
 _DASHBOARD_SCRIPT = _SCRIPTS_DIR / "dashboard-service.sh"
 _REFLEXIO_DIR = Path.home() / ".reflexio"
+_STATE_DIR = Path.home() / ".claude-smart"
+_INSTALL_FAILURE_MARKER = _STATE_DIR / "install-failed"
 _DEFAULT_STORAGE_ROOT = _REFLEXIO_DIR / "data"
 _REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / "config_self-host-org.json"
 _LOCAL_STORAGE_ENV = "LOCAL_STORAGE_PATH"
@@ -76,8 +78,11 @@ _CODEX_REQUIRED_FILES = (
     Path(".agents/plugins/marketplace.json"),
     Path("plugin/.codex-plugin/plugin.json"),
     Path("plugin/hooks/codex-hooks.json"),
-    Path("plugin/scripts/codex-claude-compat.py"),
+    Path("plugin/scripts/codex-claude-compat"),
+    Path("plugin/scripts/codex-claude-compat.cmd"),
+    Path("plugin/scripts/codex-claude-compat.js"),
     Path("plugin/scripts/codex-hook.js"),
+    Path("plugin/scripts/backend-log-runner.sh"),
     Path("plugin/scripts/_codex_env.sh"),
 )
 _COPYTREE_IGNORE = shutil.ignore_patterns(
@@ -125,6 +130,86 @@ def _seed_reflexio_env() -> list[str]:
     return missing
 
 
+def _find_claude_code_plugin_root() -> Path | None:
+    """Locate the installed Claude Code plugin root after native install."""
+    cache_root = (
+        Path.home()
+        / ".claude"
+        / "plugins"
+        / "cache"
+        / _CODEX_MARKETPLACE_NAME
+        / "claude-smart"
+    )
+    candidates: list[Path] = []
+    if cache_root.is_dir():
+        for child in cache_root.iterdir():
+            if (
+                child.is_dir()
+                and (child / "pyproject.toml").is_file()
+                and (child / "scripts" / "smart-install.sh").is_file()
+            ):
+                candidates.append(child)
+    candidates.sort(key=lambda path: path.stat().st_mtime, reverse=True)
+    candidates.extend(
+        [
+            Path.home()
+            / ".claude"
+            / "plugins"
+            / "marketplaces"
+            / _CODEX_MARKETPLACE_NAME
+            / "plugin",
+            _PLUGIN_ROOT,
+        ]
+    )
+    for candidate in candidates:
+        if (
+            (candidate / "pyproject.toml").is_file()
+            and (candidate / "scripts" / "smart-install.sh").is_file()
+        ):
+            return candidate
+    return None
+
+
+def _force_plugin_root(plugin_root: Path) -> None:
+    """Point ~/.reflexio/plugin-root at the installed plugin root."""
+    _REFLEXIO_DIR.mkdir(parents=True, exist_ok=True)
+    link = _REFLEXIO_DIR / "plugin-root"
+    if link.is_symlink() or link.is_file():
+        link.unlink()
+    elif link.exists():
+        raise OSError(f"refusing to replace non-symlink plugin-root at {link}")
+    try:
+        link.symlink_to(plugin_root, target_is_directory=True)
+    except OSError:
+        if link.exists():
+            raise
+        (_REFLEXIO_DIR / "plugin-root.txt").write_text(f"{plugin_root}\n")
+
+
+def _bootstrap_claude_code_install() -> tuple[bool, str]:
+    """Run smart-install immediately for the installed Claude Code plugin."""
+    plugin_root = _find_claude_code_plugin_root()
+    if plugin_root is None:
+        return False, "could not locate installed Claude Code plugin root after install"
+    try:
+        _force_plugin_root(plugin_root)
+    except OSError as exc:
+        return False, str(exc)
+    bash = shutil.which("bash")
+    if not bash:
+        return False, "bash is required to bootstrap claude-smart dependencies"
+    result = subprocess.run(
+        [bash, str(plugin_root / "scripts" / "smart-install.sh")],
+        cwd=plugin_root,
+    )
+    if result.returncode != 0:
+        return False, f"smart-install.sh failed in {plugin_root}"
+    if _INSTALL_FAILURE_MARKER.is_file():
+        reason = _INSTALL_FAILURE_MARKER.read_text().strip() or "unknown error"
+        return False, reason
+    return True, str(plugin_root)
+
+
 def _missing_codex_marketplace_files(root: Path) -> list[Path]:
     return [entry for entry in _CODEX_REQUIRED_FILES if not (root / entry).is_file()]
 
@@ -789,7 +874,21 @@ def cmd_install(args: argparse.Namespace) -> int:
     if added:
         sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
 
-    sys.stdout.write("\nclaude-smart installed. Restart Claude Code in your project.\n")
+    bootstrapped, message = _bootstrap_claude_code_install()
+    if not bootstrapped:
+        sys.stderr.write(
+            f"error: claude-smart installed, but dependency bootstrap failed: {message}\n"
+        )
+        sys.stderr.write(
+            "Fix the issue above, then run /claude-smart:restart or restart Claude Code to retry.\n"
+        )
+        return 1
+    sys.stdout.write(f"Prepared claude-smart runtime at {message}.\n")
+
+    sys.stdout.write(
+        "\nclaude-smart installed and dependencies are prepared. "
+        "Restart Claude Code in your project.\n"
+    )
     return 0
 
 

package/plugin/src/claude_smart/context_inject.py

@@ -6,8 +6,7 @@ search, (b) render the hits with ``context_format.render_inline_with_registry``,
 (d) emit a Claude Code ``hookSpecificOutput.additionalContext`` envelope
 on stdout. This module owns that shared pipeline so the two hook
 handlers keep exactly one source of truth for the injection contract —
-the envelope shape, the registry schema, and the ordering of
-``ensure_installed`` / ``append_injected``.
+the envelope shape, the registry schema, and the injected context append.
 
 The caller remains responsible for handler-specific framing (PreToolUse
 needs ``hook.emit_continue()`` on the empty path; UserPromptSubmit wraps
@@ -21,7 +20,7 @@ import json
 import sys
 import time
 
-from claude_smart import context_format, cs_cite, state
+from claude_smart import context_format, state
 from claude_smart.reflexio_adapter import Adapter
 
 
@@ -69,7 +68,6 @@ def emit_context(
     if not markdown:
         return False
 
-    cs_cite.ensure_installed()
     state.append_injected(
         session_id,
         (dict(entry, ts=int(time.time())) for entry in registry),

package/plugin/src/claude_smart/cs_cite.py

@@ -11,8 +11,7 @@ impactful replies with a marker like::
 
 The Stop hook later scans the assistant text for those markers and resolves
 the ids against a per-session registry persisted at
-``~/.claude-smart/sessions/<session_id>.injected.jsonl``. Legacy ``cs-cite``
-Bash tool calls are still accepted as a fallback for older instructions.
+``~/.claude-smart/sessions/<session_id>.injected.jsonl``.
 
 Why rank + fingerprint: rank alone resets at every injection, so a
 later injection's ``s1`` would silently overwrite an earlier entry in
@@ -27,48 +26,19 @@ This module holds:
 - ``rank_id``: ``p{n}-{fp}`` / ``s{n}-{fp}`` tag for a given
   (kind, rank, real_id) tuple. Fingerprint is omitted when no real id
   is available. ``p`` is preference, ``s`` is skill.
-- ``CITATION_CMD_RE``: regex matching a valid legacy ``cs-cite`` command line.
-- ``ensure_installed``: idempotent copy of ``plugin/bin/cs-cite`` to
-  ``~/.claude-smart/bin/cs-cite`` with the executable bit set.
 - ``CITATION_INSTRUCTION``: the trailer text appended to injected context
   so the assistant knows when and how to emit the citation marker.
 """
 
 from __future__ import annotations
 
-import logging
 import re
-import shutil
-import stat as stat_
-from pathlib import Path
 from typing import Any
 
-_LOGGER = logging.getLogger(__name__)
-
-_THIS_DIR = Path(__file__).resolve().parent
-_PLUGIN_ROOT = _THIS_DIR.parents[1]  # plugin/src/claude_smart/ -> plugin/
-_SOURCE_SCRIPT = _PLUGIN_ROOT / "bin" / "cs-cite"
-_INSTALL_DIR = Path.home() / ".claude-smart" / "bin"
-INSTALL_PATH = _INSTALL_DIR / "cs-cite"
-
 _FINGERPRINT_LEN = 4
 
-# Match a bare `cs-cite <ids>` invocation. Ids are rank tokens of the
-# form `p<N>` (preference) or `s<N>` (skill) with an optional
-# `-<fp>` fingerprint (1-4 alphanumeric chars), optionally
-# `cs:`-prefixed (since bullets render as `[cs:p1-ab12]` and the model
-# often copies the tag verbatim). The `(?i:...)` inline flags make the
-# prefix, kind letter, and fingerprint case-insensitive so `CS:P1-AB12`
-# is accepted — matching the `re.IGNORECASE` used by the standalone
-# `cs-cite` script. Tokens may be comma- and/or whitespace-separated.
-# Chained commands (&&, |, ;) and extra trailing tokens remain rejected
-# by the anchored `\s*$` terminator so accidental mentions don't
-# register as citations.
 _ID_TOKEN = r"(?i:cs:)?(?i:[ps])\d+(?:-(?i:[a-z0-9]){1,4})?"
 _ID_SEP = r"[,\s]+"
-CITATION_CMD_RE = re.compile(
-    rf"^\s*(?:[^\s]*/)?cs-cite\s+({_ID_TOKEN}(?:{_ID_SEP}{_ID_TOKEN})*)\s*$"
-)
 _CLEAN_ID_RE = re.compile(r"^(?i:cs:)?((?i:[ps])\d+(?:-(?i:[a-z0-9]){1,4})?)$")
 _SPLIT_RE = re.compile(_ID_SEP)
 _TEXT_CITATION_LINE_RE = re.compile(
@@ -82,7 +52,7 @@ CITATION_INSTRUCTION = (
     "only if — an injected `[cs:…]` item materially changed your reply "
     "(different wording, action, or conclusion than you would have produced "
     "without it), append exactly one final citation line after your answer. "
-    "Do not call `cs-cite` or any other tool for citations. Ids come verbatim "
+    "Do not call a shell command or any other tool for citations. Ids come verbatim "
     "from the `[cs:…]` tags — keep the leading `p` (preference) or `s` "
     "(skill) and the `-<fp>` suffix. Use this exact format for one id: "
     "`✨ 1 claude-smart learning applied [cs:s1-ab12]`. Use this exact format "
@@ -155,29 +125,6 @@ def rank_id(kind: str, rank: int, real_id: Any = None) -> str:
     return f"{prefix}{rank}-{fp}" if fp else f"{prefix}{rank}"
 
 
-def parse_citation_command(command: str) -> list[str]:
-    """Extract citation ids from a ``cs-cite`` Bash command string.
-
-    Returns an empty list when the command does not match the expected
-    shape (chained commands, extra arguments, or anything other than a
-    bare ``cs-cite <ids>`` invocation are rejected to avoid false
-    positives from accidental mentions).
-
-    Args:
-        command: The raw ``input.command`` value from a Bash tool_use
-            block.
-
-    Returns:
-        list[str]: Lowercase rank ids (e.g. ``"p1"``, ``"s3"``), in the
-            order Claude cited them. Empty when the command does not
-            match.
-    """
-    match = CITATION_CMD_RE.match(command or "")
-    if not match:
-        return []
-    return _parse_id_tokens(match.group(1))
-
-
 def parse_text_citations(text: str) -> list[str]:
     """Extract Codex text-only citation ids from a final learning marker line.
 
@@ -199,38 +146,3 @@ def _parse_id_tokens(raw_ids: str) -> list[str]:
         if clean := _CLEAN_ID_RE.match(tok):
             ids.append(clean.group(1).lower())
     return ids
-
-
-def ensure_installed() -> Path:
-    """Idempotently install ``cs-cite`` into ``~/.claude-smart/bin/``.
-
-    Called from every PreToolUse / UserPromptSubmit inject, so we
-    short-circuit when the target file already exists with
-    the executable bit set — the steady-state path is one ``stat`` syscall
-    instead of mkdir + copy + stat + chmod. Keying on filesystem state
-    (rather than a module-level boolean) keeps test isolation working when
-    tests monkeypatch ``INSTALL_PATH`` to a fresh tmpdir.
-
-    Never raises — filesystem errors are logged at DEBUG and the caller
-    proceeds with injection regardless (the citation feature degrades to
-    silent if the script is unreachable).
-
-    Returns:
-        Path: Target path, whether or not install succeeded.
-    """
-    try:
-        if (
-            INSTALL_PATH.is_file()
-            and INSTALL_PATH.stat().st_mode & stat_.S_IXUSR
-            and _SOURCE_SCRIPT.is_file()
-            and INSTALL_PATH.read_bytes() == _SOURCE_SCRIPT.read_bytes()
-        ):
-            return INSTALL_PATH
-        _INSTALL_DIR.mkdir(parents=True, exist_ok=True)
-        if _SOURCE_SCRIPT.is_file():
-            shutil.copy2(_SOURCE_SCRIPT, INSTALL_PATH)
-            mode = INSTALL_PATH.stat().st_mode
-            INSTALL_PATH.chmod(mode | stat_.S_IXUSR | stat_.S_IXGRP | stat_.S_IXOTH)
-    except OSError as exc:
-        _LOGGER.debug("cs-cite install failed: %s", exc)
-    return INSTALL_PATH

package/plugin/src/claude_smart/events/stop.py

@@ -34,7 +34,7 @@ _EXIT_PLAN_MODE_TOOL = "ExitPlanMode"
 def _read_transcript_entries(path: Path) -> list[dict[str, Any]]:
     """Parse the transcript JSONL once into a list of entries.
 
-    Stop's three scanners (assistant text, cs-cite ids, plan decisions) all
+    Stop's scanners (assistant text and plan decisions) both
     need the same parsed view; reading once and passing the list around keeps
     the hook's wall-clock cost to a single ``read_text`` per fire even on
     multi-megabyte transcripts.
@@ -267,43 +267,10 @@ def _parse_plan_decision(text: str) -> str | None:
     return None
 
 
-def _scan_transcript_for_cs_cite_ids(entries: list[dict[str, Any]]) -> list[str]:
-    """Scan the current assistant turn for ``cs-cite`` Bash tool_use calls.
-
-    Collects citation ids from every matching Bash ``tool_use`` block in
-    the current turn. Multiple calls are merged; order follows Claude's
-    emission order (earliest first).
-
-    Args:
-        entries (list[dict[str, Any]]): Pre-parsed transcript entries.
-
-    Returns:
-        list[str]: Rank ids (e.g. ``"s1-ab12"``, ``"p2-cd34"``) in
-            emission order. Empty when no ``cs-cite`` call is found.
-    """
-    out: list[str] = []
-    for entry in _current_turn_assistant_entries(entries):
-        message = entry.get("message") or {}
-        out.extend(_extract_cs_cite_ids(message.get("content")))
-    return out
-
-
-def _extract_cs_cite_ids(content: Any) -> list[str]:
-    """Return citation ids from all Bash ``cs-cite`` tool_use blocks in ``content``."""
-    if not isinstance(content, list):
-        return []
-    out: list[str] = []
-    for block in content:
-        if not isinstance(block, dict) or block.get("type") != "tool_use":
-            continue
-        if block.get("name") != "Bash":
-            continue
-        tool_input = block.get("input") or {}
-        command = tool_input.get("command")
-        if not isinstance(command, str):
-            continue
-        out.extend(cs_cite.parse_citation_command(command))
-    return out
+def _has_unpublished_user_turn(session_id: str) -> bool:
+    """True when the session buffer already has a user turn awaiting publish."""
+    _, interactions = state.unpublished_slice(state.read_all(session_id))
+    return any(item.get("role") == "User" for item in interactions)
 
 
 def _resolve_cited_items(session_id: str, cited_ids: list[str]) -> list[dict[str, Any]]:
@@ -360,8 +327,10 @@ def handle(payload: dict[str, Any]) -> None:
         if path.is_file():
             entries = _load_transcript_with_retry(path)
 
+    prompt = payload.get("prompt") or (
+        _scan_transcript_for_user_text(entries) if runtime.is_codex() else ""
+    )
     if runtime.is_codex():
-        prompt = payload.get("prompt") or _scan_transcript_for_user_text(entries)
         if internal_call.is_codex_internal_prompt(prompt):
             return
 
@@ -373,10 +342,15 @@ def handle(payload: dict[str, Any]) -> None:
         and last_assistant_message
         else _scan_transcript_for_assistant_text(entries)
     )
-    transcript_cited_ids = _scan_transcript_for_cs_cite_ids(entries)
+    if (
+        runtime.is_codex()
+        and internal_call.is_codex_title_response(assistant_text)
+        and not prompt
+        and not _has_unpublished_user_turn(session_id)
+    ):
+        return
     text_cited_ids = cs_cite.parse_text_citations(assistant_text)
-    cited_ids = [*text_cited_ids, *transcript_cited_ids]
-    cited_items = _resolve_cited_items(session_id, cited_ids)
+    cited_items = _resolve_cited_items(session_id, text_cited_ids)
     plan_decisions = _scan_transcript_for_plan_decisions(entries)
 
     now = int(time.time())

package/plugin/src/claude_smart/internal_call.py

@@ -36,6 +36,7 @@ Detection signals, OR'd:
 
 from __future__ import annotations
 
+import json
 import os
 from pathlib import Path
 from typing import Any
@@ -117,3 +118,25 @@ def is_codex_internal_prompt(prompt: Any) -> bool:
         and _CODEX_SUGGESTIONS_PROMPT_MARKER in text
         and _CODEX_SUGGESTIONS_APPS_MARKER in text
     )
+
+
+def is_codex_title_response(content: Any) -> bool:
+    """True for Codex's title-generator response body.
+
+    Codex can run a separate title-generation task whose Stop payload contains
+    only the assistant response, e.g. ``{"title":"Fix tests"}``, with no
+    corresponding user turn. That metadata is useful to Codex's UI, but it is
+    not a user interaction and should not be published to reflexio.
+    """
+    if not isinstance(content, str):
+        return False
+    try:
+        parsed = json.loads(content)
+    except json.JSONDecodeError:
+        return False
+    return (
+        isinstance(parsed, dict)
+        and set(parsed) == {"title"}
+        and isinstance(parsed.get("title"), str)
+        and bool(parsed["title"].strip())
+    )

package/plugin/src/claude_smart/state.py

@@ -77,7 +77,7 @@ def session_path(session_id: str) -> Path:
 
 
 def injected_path(session_id: str) -> Path:
-    """Return the JSONL path for the per-session cs-cite registry."""
+    """Return the JSONL path for the per-session citation registry."""
     return state_dir() / f"{session_id}.injected.jsonl"
 
 
@@ -85,8 +85,8 @@ def append_injected(session_id: str, entries: Iterable[dict[str, Any]]) -> None:
     """Append citation-registry entries to the per-session injected-items file.
 
     Each entry maps a short ``id`` (4-hex-char) back to the skill or
-    preference it came from so the Stop hook can resolve ids cited by
-    Claude via ``cs-cite`` into human-readable titles for the dashboard.
+    preference it came from so the Stop hook can resolve citation ids into
+    human-readable titles for the dashboard.
     Silently no-ops when ``entries`` is empty.
     """
     records = list(entries)