claude-smart 0.2.23 → 0.2.24

package/plugin/src/claude_smart/internal_call.py

@@ -0,0 +1,89 @@
+"""Detect hook invocations that should not be published to reflexio.
+
+Two distinct sources of unwanted hook fires:
+
+1. **Reflexio's own LLM provider.** The ``claude-code`` LiteLLM provider
+   (see ``reflexio.server.llm.providers.claude_code_provider._run_cli``)
+   shells out to the ``claude`` CLI to answer extractor prompts. That
+   subprocess is a full Claude Code invocation, so it fires *our* hooks
+   too — and without a guard, the Stop hook publishes the extractor's
+   own system prompt back into reflexio as a user interaction.
+   Reflexio then trains on its own internals.
+
+2. **Other tools' headless ``claude -p`` subprocesses.** Third-party
+   plugins (e.g. claude-mem) spawn their own ``claude -p`` sessions
+   for memory/observation extraction. Those sessions also fire the
+   user's globally-installed claude-smart hooks, and the system prompt
+   passed to ``-p`` shows up in the transcript as a user message —
+   leaking text like ``"You are a Claude-Mem, a specialized observer
+   tool..."`` into reflexio as a fake user interaction.
+
+Detection signals, OR'd:
+  - ``CLAUDE_CODE_ENTRYPOINT`` is anything other than ``"cli"`` —
+    the interactive REPL sets ``cli``; headless ``claude -p`` sets
+    ``sdk-cli`` (and the SDKs may set other values). This catches
+    case (2) for any third-party tool, not just claude-mem.
+  - Env var ``CLAUDE_SMART_INTERNAL=1``, set by reflexio's provider
+    before spawning ``claude``. Belt-and-suspenders for case (1) in
+    case the entrypoint check ever misses a future SDK variant.
+  - ``payload.cwd`` resolves inside the reflexio submodule. Catches
+    direct interactive ``claude`` runs from inside reflexio (manual
+    debugging) that would otherwise pollute the corpus.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from claude_smart import runtime
+
+_ENTRYPOINT_VAR = "CLAUDE_CODE_ENTRYPOINT"
+_INTERACTIVE_ENTRYPOINT = "cli"
+
+# Reflexio submodule lives at <repo>/reflexio when this package runs from
+# a dev checkout (<repo>/plugin/src/claude_smart/internal_call.py); anchor
+# relative to this file so the check follows the real checkout if the
+# repo is relocated. In install mode the submodule is absent — the env
+# marker is the primary signal and this path never matches.
+#
+# The path computation is tightly coupled to the current layout: if this
+# module moves, ``_REFLEXIO_DIR`` silently stops matching and only the
+# env signal remains. ``CLAUDE_SMART_REFLEXIO_DIR`` lets callers (and
+# tests) override the path without touching the module.
+_THIS_DIR = Path(__file__).resolve().parent
+_REFLEXIO_DIR = Path(
+    os.environ.get("CLAUDE_SMART_REFLEXIO_DIR") or _THIS_DIR.parents[2] / "reflexio"
+)
+
+
+def is_internal_invocation(payload: dict[str, Any]) -> bool:
+    """True if this hook fire originated from reflexio's own LLM provider.
+
+    Args:
+        payload (dict[str, Any]): Parsed Claude Code hook payload. Only
+            ``cwd`` is inspected.
+
+    Returns:
+        bool: True when the env marker is set or ``cwd`` points inside
+            the reflexio submodule. False otherwise, including when
+            ``cwd`` is missing or unresolvable.
+    """
+    if runtime.is_internal_invocation_env():
+        return True
+    entrypoint = os.environ.get(_ENTRYPOINT_VAR)
+    if entrypoint and entrypoint != _INTERACTIVE_ENTRYPOINT:
+        return True
+    cwd = payload.get("cwd")
+    if not isinstance(cwd, str) or not cwd:
+        return False
+    try:
+        resolved = Path(cwd).resolve()
+    except OSError:
+        return False
+    try:
+        resolved.relative_to(_REFLEXIO_DIR)
+    except ValueError:
+        return False
+    return True

package/plugin/src/claude_smart/optimizer_assistant.py

@@ -0,0 +1,203 @@
+"""Local-script assistant backend for Reflexio playbook optimization.
+
+Reflexio's ``LocalScriptAssistant`` sends one JSON payload on stdin and expects
+one JSON object on stdout. This module bridges that protocol to a guarded
+``claude -p`` subprocess so candidate playbooks can be evaluated against Claude
+Code without re-entering claude-smart/reflexio hooks.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from typing import Any
+
+from claude_smart import internal_call, runtime
+
+_CLAUDE_TIMEOUT_SECONDS = 300
+_READ_ONLY_TOOLS = "Read,Grep,Glob,LS"
+_MUTATING_TOOLS = "Bash,Edit,Write,MultiEdit,NotebookEdit"
+
+
+class OptimizerAssistantError(Exception):
+    """Raised for any local assistant protocol or Claude CLI failure."""
+
+
+def main() -> int:
+    """Console-script entrypoint for ``claude-smart-optimizer-assistant``."""
+    try:
+        payload = _read_payload()
+        messages = _validated_list(payload, "messages")
+        playbooks = _validated_list(payload, "playbooks")
+        prompt, system_prompt = _build_prompt(messages, playbooks)
+        content = _run_claude(prompt=prompt, system_prompt=system_prompt)
+    except Exception as exc:  # noqa: BLE001 - script errors become LocalScript failures.
+        sys.stderr.write(f"{type(exc).__name__}: {exc}\n")
+        return 1
+
+    json.dump({"content": content}, sys.stdout, ensure_ascii=False)
+    sys.stdout.write("\n")
+    return 0
+
+
+def _read_payload() -> dict[str, Any]:
+    raw = sys.stdin.read()
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise OptimizerAssistantError("stdin must be a JSON object") from exc
+    if not isinstance(payload, dict):
+        raise OptimizerAssistantError("stdin must be a JSON object")
+    return payload
+
+
+def _validated_list(payload: dict[str, Any], field: str) -> list[Any]:
+    value = payload.get(field)
+    if not isinstance(value, list):
+        raise OptimizerAssistantError(f"payload.{field} must be a list")
+    return value
+
+
+def _build_prompt(messages: list[Any], playbooks: list[Any]) -> tuple[str, str]:
+    normalized = [_normalize_message(message) for message in messages]
+    normalized = [message for message in normalized if message["content"]]
+    if not normalized:
+        raise OptimizerAssistantError("payload.messages must contain content")
+
+    final_message = normalized[-1]
+    prior_messages = normalized[:-1]
+
+    system_sections = [_render_playbooks(playbooks)]
+    existing_system = [
+        message["content"] for message in normalized if message["role"] == "system"
+    ]
+    if existing_system:
+        system_sections.append(
+            "## Existing system context\n" + "\n\n".join(existing_system)
+        )
+
+    prior_dialogue = [
+        message
+        for message in prior_messages
+        if message["role"] in {"user", "assistant"}
+    ]
+    if prior_dialogue:
+        system_sections.append(
+            "## Conversation so far\n" + _render_transcript(prior_dialogue)
+        )
+
+    prompt = final_message["content"]
+    if final_message["role"] != "user":
+        prompt = _render_transcript([final_message])
+    system_prompt = "\n\n".join(section for section in system_sections if section)
+    return prompt, system_prompt
+
+
+def _normalize_message(message: Any) -> dict[str, str]:
+    if not isinstance(message, dict):
+        raise OptimizerAssistantError("each message must be an object")
+    role = str(message.get("role") or "user").strip().lower()
+    if role not in {"user", "assistant", "system"}:
+        role = "user"
+    content = message.get("content")
+    if not isinstance(content, str):
+        raise OptimizerAssistantError("each message.content must be a string")
+    return {"role": role, "content": content.strip()}
+
+
+def _render_playbooks(playbooks: list[Any]) -> str:
+    if not playbooks:
+        return ""
+    lines = ["## Candidate playbook rules"]
+    for index, playbook in enumerate(playbooks, start=1):
+        if not isinstance(playbook, dict):
+            raise OptimizerAssistantError("each playbook must be an object")
+        content = playbook.get("content")
+        if not isinstance(content, str) or not content.strip():
+            raise OptimizerAssistantError("each playbook.content must be a string")
+        trigger = playbook.get("trigger")
+        suffix = ""
+        if isinstance(trigger, str) and trigger.strip():
+            suffix = f" (when: {trigger.strip()})"
+        lines.append(f"{index}. {content.strip()}{suffix}")
+    return "\n".join(lines)
+
+
+def _render_transcript(messages: list[dict[str, str]]) -> str:
+    labels = {"user": "User", "assistant": "Assistant", "system": "System"}
+    return "\n\n".join(
+        f"{labels.get(message['role'], 'User')}: {message['content']}"
+        for message in messages
+    )
+
+
+def _run_claude(*, prompt: str, system_prompt: str) -> str:
+    cli_path = shutil.which("claude") or "claude"
+    # This is an evaluation rollout, not a real user session: allow local
+    # inspection, but prevent filesystem, shell, MCP, and session mutations.
+    cmd = [
+        cli_path,
+        "-p",
+        "--output-format",
+        "json",
+        "--permission-mode",
+        "plan",
+        "--tools",
+        _READ_ONLY_TOOLS,
+        "--disallowedTools",
+        _MUTATING_TOOLS,
+        "--no-session-persistence",
+        "--mcp-config",
+        '{"mcpServers": {}}',
+        "--strict-mcp-config",
+    ]
+    if system_prompt:
+        cmd.extend(["--append-system-prompt", system_prompt])
+
+    env = os.environ.copy()
+    env[runtime.INTERNAL_ENV] = "1"
+    env[internal_call._ENTRYPOINT_VAR] = "optimizer"  # noqa: SLF001
+
+    try:
+        proc = subprocess.run(  # noqa: S603 - command is fixed plus resolved executable.
+            cmd,
+            input=prompt,
+            capture_output=True,
+            text=True,
+            timeout=_CLAUDE_TIMEOUT_SECONDS,
+            check=False,
+            env=env,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise OptimizerAssistantError(
+            f"claude CLI timed out after {_CLAUDE_TIMEOUT_SECONDS}s"
+        ) from exc
+    except FileNotFoundError as exc:
+        raise OptimizerAssistantError("claude CLI not found on PATH") from exc
+
+    if proc.returncode != 0:
+        stderr = proc.stderr.strip()
+        raise OptimizerAssistantError(
+            f"claude CLI exited {proc.returncode}: {stderr[:500]}"
+        )
+
+    try:
+        data = json.loads(proc.stdout)
+    except json.JSONDecodeError as exc:
+        raise OptimizerAssistantError("claude CLI returned non-JSON output") from exc
+    if not isinstance(data, dict):
+        raise OptimizerAssistantError("claude CLI JSON output must be an object")
+
+    content = data.get("result")
+    if not isinstance(content, str):
+        content = data.get("response")
+    if not isinstance(content, str):
+        raise OptimizerAssistantError("claude CLI JSON output missing result/response")
+    return content
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugin/src/claude_smart/publish.py

@@ -0,0 +1,71 @@
+"""Publish-to-reflexio orchestration used by Stop, SessionEnd, and the sync CLI.
+
+One helper — ``publish_unpublished`` — owns the read-buffer → slice → publish →
+stamp-watermark sequence so the three call sites stay in sync. Returns a
+``(status, interaction_count)`` tuple so callers can format appropriate
+messaging without peeking at the adapter.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from claude_smart import state
+from claude_smart.reflexio_adapter import Adapter
+
+PublishStatus = Literal["nothing", "ok", "failed"]
+
+
+def publish_unpublished(
+    *,
+    session_id: str,
+    project_id: str,
+    force_extraction: bool,
+    skip_aggregation: bool,
+    adapter: Adapter | None = None,
+) -> tuple[PublishStatus, int]:
+    """Drain the session buffer to reflexio and stamp the high-water mark.
+
+    Args:
+        session_id (str): Claude Code session id, attached to each interaction.
+        project_id (str): Stable project name; used as reflexio's
+            ``user_id`` (preferences) so preferences accumulate at the project
+            level across sessions. ``agent_version`` is hardcoded to
+            ``"claude-code"`` in the adapter so skills roll up
+            globally per agent rather than per project.
+        force_extraction (bool): Whether to ask reflexio to run extraction
+            synchronously instead of queuing for the next sweep.
+        skip_aggregation (bool): When True, reflexio extracts preferences and
+            raw project-specific skill entries but skips the rollup into
+            shared skills. claude-smart passes False on every publish
+            path so ``user_playbooks`` roll up into ``agent_playbooks``; aggregation
+            additionally requires `aggregation_config` to be set on
+            reflexio's `user_playbook_extractor_configs[0]` and
+            `optimize_agent_playbooks=true` at the top level — otherwise
+            the rollup silently no-ops.
+        adapter (Adapter | None): Injection point for tests; a fresh
+            ``Adapter()`` is constructed when omitted.
+
+    Returns:
+        tuple[PublishStatus, int]: ``("nothing", 0)`` if the buffer has no
+            unpublished turns, ``("ok", n)`` after a successful publish of
+            ``n`` interactions, or ``("failed", n)`` if reflexio rejected or
+            was unreachable. On ``"failed"`` the watermark is not advanced,
+            so the next hook retries the same batch.
+    """
+    records = state.read_all(session_id)
+    _, interactions = state.unpublished_slice(records)
+    if not interactions:
+        return ("nothing", 0)
+    client = adapter if adapter is not None else Adapter()
+    ok = client.publish(
+        session_id=session_id,
+        project_id=project_id,
+        interactions=interactions,
+        force_extraction=force_extraction,
+        skip_aggregation=skip_aggregation,
+    )
+    if ok:
+        state.append(session_id, {"published_up_to": len(records)})
+        return ("ok", len(interactions))
+    return ("failed", len(interactions))

package/plugin/src/claude_smart/query_compose.py

@@ -0,0 +1,51 @@
+"""Compose a reflexio search query from a PreToolUse payload.
+
+Deterministic — no LLM call — so the PreToolUse hook can stay inside its
+latency budget. The output is fed to ``ReflexioClient.search(query=...)``
+(the unified ``/api/search`` endpoint, which fans out to user playbooks,
+agent playbooks, and preferences server-side), which tokenizes via reflexio's
+FTS5 sanitizer (OR-joined, stemmed) plus a vector-similarity leg. Short,
+meaning-dense strings give the most selective hybrid ranking.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+_MAX_SNIPPET_LEN = 400
+
+
+def from_tool_call(tool_name: str, tool_input: Mapping[str, Any]) -> str:
+    """Compose a search query from a Claude Code PreToolUse payload.
+
+    Args:
+        tool_name (str): Claude Code tool name (e.g. ``"Edit"``, ``"Bash"``).
+        tool_input (Mapping[str, Any]): The tool's input dict as delivered
+            by the hook payload.
+
+    Returns:
+        str: A short query suitable for reflexio hybrid search, or ``""``
+            when the tool is not one we compose for (caller should then
+            skip the search entirely).
+    """
+    match tool_name:
+        case "Edit" | "Write" | "NotebookEdit":
+            return _from_file_edit(tool_input)
+        case "Bash":
+            return _from_bash(tool_input)
+        case _:
+            return ""
+
+
+def _from_file_edit(tool_input: Mapping[str, Any]) -> str:
+    path = tool_input.get("file_path") or ""
+    snippet = tool_input.get("new_string") or tool_input.get("content") or ""
+    basename = Path(path).name if path else ""
+    return f"{basename} {snippet[:_MAX_SNIPPET_LEN]}".strip()
+
+
+def _from_bash(tool_input: Mapping[str, Any]) -> str:
+    command = tool_input.get("command") or ""
+    first_line = command.splitlines()[0] if command else ""
+    return first_line[:_MAX_SNIPPET_LEN].strip()