claude-smart 0.2.23 → 0.2.25

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

@@ -0,0 +1,148 @@
+"""PostToolUse hook — record the tool invocation and its outcome."""
+
+from __future__ import annotations
+
+import re
+import time
+from typing import Any
+
+from claude_smart import state
+
+# Tool inputs are persisted locally and later published to reflexio, so we
+# apply a conservative redaction pass at ingestion time. Chosen to avoid
+# false positives over maximal coverage — the dashboard shows these
+# verbatim, and users noticing a masked command is far less surprising
+# than a masked `LOG_LEVEL=INFO`.
+_MAX_STR_LEN = 4096
+_SECRET_ASSIGNMENT = re.compile(
+    r"(?P<key>[A-Z][A-Z0-9_]{2,})=(?P<quote>['\"]?)"
+    r"(?P<value>[A-Za-z0-9+/=_\-]{20,})(?P=quote)"
+)
+
+
+def _looks_like_secret(value: str) -> bool:
+    """Heuristic: mixed-case letters plus digits suggest a high-entropy token."""
+    has_lower = any(c.islower() for c in value)
+    has_upper = any(c.isupper() for c in value)
+    has_digit = any(c.isdigit() for c in value)
+    return has_lower and has_upper and has_digit
+
+
+def _mask_secrets(text: str) -> str:
+    def sub(match: "re.Match[str]") -> str:
+        value = match.group("value")
+        if not _looks_like_secret(value):
+            return match.group(0)
+        key = match.group("key")
+        quote = match.group("quote")
+        return f"{key}={quote}<redacted:{len(value)}>{quote}"
+
+    return _SECRET_ASSIGNMENT.sub(sub, text)
+
+
+def _redact_string(value: str) -> str:
+    masked = _mask_secrets(value)
+    if len(masked) > _MAX_STR_LEN:
+        return masked[:_MAX_STR_LEN] + "…(truncated)"
+    return masked
+
+
+def _redact(tool_input: dict[str, Any]) -> dict[str, Any]:
+    """Redact obvious secrets and truncate oversized string values.
+
+    Only top-level string values are inspected — nested dicts/lists and
+    non-string scalars pass through unchanged. Claude Code tool payloads
+    are flat in practice (Bash.command, Edit.file_path, etc.), so deeper
+    recursion isn't worth the false-positive surface.
+
+    Args:
+        tool_input (dict[str, Any]): Raw ``tool_input`` from the PostToolUse
+            payload.
+
+    Returns:
+        dict[str, Any]: New dict with redaction applied.
+    """
+    return {
+        k: _redact_string(v) if isinstance(v, str) else v for k, v in tool_input.items()
+    }
+
+
+def _derive_status(tool_response: Any) -> str:
+    """Classify the tool outcome as 'success' or 'error'.
+
+    Claude Code's PostToolUse payload puts the tool response under
+    ``tool_response``, which may be a dict (with an ``is_error`` / ``error``
+    field) or a bare string. Unknown shapes default to success.
+    """
+    if isinstance(tool_response, dict):
+        if tool_response.get("is_error") or tool_response.get("error"):
+            return "error"
+    return "success"
+
+
+_OUTPUT_TEXT_KEYS = ("stdout", "stderr", "output", "content", "text", "error")
+
+
+def _flatten_tool_response_text(tool_response: Any) -> str:
+    """Flatten ``tool_response`` into a single string for buffering.
+
+    Claude Code delivers tool responses in heterogeneous shapes — Bash sends
+    a dict with ``stdout``/``stderr``, Edit/Read send a string or a dict
+    with ``content``/``output``, and failures populate ``error``. Joining
+    the well-known string-valued keys preserves the parts most useful for
+    downstream learning (failure messages, command output) without
+    serializing entire structured payloads.
+
+    Note: structured ``content`` lists (e.g. ``[{type: 'text', text: ...}]``)
+    are not flattened — only top-level string values are joined. If a tool
+    starts emitting block-form content we want to capture, add a dedicated
+    branch here.
+
+    Args:
+        tool_response (Any): The raw ``tool_response`` from the PostToolUse
+            payload.
+
+    Returns:
+        str: A flattened string. Empty when no textual content is present.
+    """
+    if tool_response is None:
+        return ""
+    if isinstance(tool_response, str):
+        return tool_response
+    if isinstance(tool_response, dict):
+        parts = [
+            tool_response[key]
+            for key in _OUTPUT_TEXT_KEYS
+            if isinstance(tool_response.get(key), str) and tool_response[key]
+        ]
+        if parts:
+            return "\n".join(parts)
+        for key in ("text", "content"):
+            value = tool_response.get(key)
+            if isinstance(value, str):
+                return value
+        return ""
+    for attr in ("text", "content"):
+        value = getattr(tool_response, attr, None)
+        if isinstance(value, str):
+            return value
+    return ""
+
+
+def handle(payload: dict[str, Any]) -> None:
+    session_id = payload.get("session_id")
+    tool_name = payload.get("tool_name") or ""
+    if not session_id or not tool_name:
+        return
+
+    tool_response = payload.get("tool_response")
+    output_text = _flatten_tool_response_text(tool_response)
+    record = {
+        "ts": int(time.time()),
+        "role": "Assistant_tool",
+        "tool_name": tool_name,
+        "tool_input": _redact(payload.get("tool_input") or {}),
+        "tool_output": _redact_string(output_text) if output_text else "",
+        "status": _derive_status(tool_response),
+    }
+    state.append(session_id, record)

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

@@ -0,0 +1,52 @@
+"""PreToolUse hook — just-in-time skill + preference inject before a mutating tool.
+
+Fires only for tools listed in ``hooks.json``'s PreToolUse matcher
+(Edit/Write/NotebookEdit/Bash). Composes a query from the tool call and
+delegates to ``context_inject.emit_context`` for the shared
+search-render-emit pipeline, falling back to ``hook.emit_continue`` when
+there is nothing to inject or the search raises.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from claude_smart import context_inject, hook, ids, query_compose, runtime
+
+_LOGGER = logging.getLogger(__name__)
+_TOP_K = 3
+
+
+def handle(payload: dict[str, Any]) -> None:
+    """PreToolUse dispatcher — never raises; degrades to ``emit_continue``."""
+    if runtime.is_codex():
+        hook.emit_continue()
+        return
+
+    session_id = payload.get("session_id")
+    tool_name = payload.get("tool_name")
+    tool_input = payload.get("tool_input") or {}
+    if not session_id or not tool_name:
+        hook.emit_continue()
+        return
+
+    query = query_compose.from_tool_call(tool_name, tool_input)
+    if not query:
+        hook.emit_continue()
+        return
+
+    project_id = ids.resolve_project_id(payload.get("cwd"))
+    try:
+        emitted = context_inject.emit_context(
+            session_id=session_id,
+            project_id=project_id,
+            query=query,
+            hook_event_name="PreToolUse",
+            top_k=_TOP_K,
+        )
+    except Exception as exc:  # noqa: BLE001 — never block a tool call.
+        _LOGGER.debug("pre_tool context inject failed: %s", exc)
+        emitted = False
+    if not emitted:
+        hook.emit_continue()

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

@@ -0,0 +1,20 @@
+"""SessionEnd hook — flush any remaining interactions; extraction runs async."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from claude_smart import ids, publish
+
+
+def handle(payload: dict[str, Any]) -> None:
+    session_id = payload.get("session_id")
+    if not session_id:
+        return
+    project_id = ids.resolve_project_id(payload.get("cwd"))
+    publish.publish_unpublished(
+        session_id=session_id,
+        project_id=project_id,
+        force_extraction=False,
+        skip_aggregation=False,
+    )

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

@@ -0,0 +1,119 @@
+"""SessionStart hook — apply startup defaults without broad memory retrieval."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from claude_smart import hook
+from claude_smart.reflexio_adapter import Adapter
+from claude_smart.stall_banner import render_banner
+
+# Claude-smart's preferred extraction cadence — more frequent, smaller windows
+# than reflexio's out-of-box 10/5. Applied idempotently to the reflexio server
+# on every SessionStart via Adapter.apply_extraction_defaults.
+_CLAUDE_SMART_WINDOW_SIZE = 5
+_CLAUDE_SMART_STRIDE_SIZE = 3
+# Optimizer is on by default. Set this env var to "0" to skip pushing the
+# claude-smart optimizer defaults on SessionStart (kill switch).
+_DISABLE_OPTIMIZER_ENV = "CLAUDE_SMART_ENABLE_OPTIMIZER"
+_OPTIMIZER_TIMEOUT_SECONDS = 300
+
+
+def _adapter() -> Adapter:
+    """Construct the reflexio adapter for this hook invocation.
+
+    Indirected through a factory so tests can monkeypatch the adapter
+    construction without touching the ``Adapter`` class itself.
+
+    Returns:
+        Adapter: A fresh adapter bound to the current process env.
+    """
+    return Adapter()
+
+
+def _stall_banner(adapter: Any) -> str:
+    """Return the prepend-able stall banner, or "" if no banner should fire.
+
+    Reads ``adapter.fetch_stall_state()``; if it reports an active, not-yet-
+    notified stall, renders a one-line banner via ``stall_banner.render_banner``.
+    All exceptions are absorbed: this is defense-in-depth — even though the
+    hook dispatcher already wraps ``handle`` in try/except, a stall-path bug
+    must never block the existing playbook/profile rendering.
+
+    Args:
+        adapter (Any): The adapter to query. Duck-typed so tests can stub.
+
+    Returns:
+        str: The banner text, or ``""`` when there is nothing to show.
+    """
+    try:
+        state_obj = adapter.fetch_stall_state()
+    except Exception:  # noqa: BLE001 — stall path must never crash the hook.
+        return ""
+    if state_obj is None:
+        return ""
+    if not getattr(state_obj, "stalled", False):
+        return ""
+    if getattr(state_obj, "notified_in_cc", False):
+        return ""
+    try:
+        return render_banner(
+            reason=getattr(state_obj, "reason", None),
+            reset_estimate=getattr(state_obj, "reset_estimate", None),
+        )
+    except Exception:  # noqa: BLE001 — render_banner bug must not block playbook injection.
+        return ""
+
+
+def handle(payload: dict[str, Any]) -> None:
+    session_id = payload.get("session_id")
+    if not session_id:
+        hook.emit_continue()
+        return
+
+    adapter = _adapter()
+
+    # Stall banner — prepended to additionalContext, fires at most once per
+    # stall event (controlled server-side via mark_stall_notified).
+    banner = _stall_banner(adapter)
+
+    adapter.apply_extraction_defaults(
+        window_size=_CLAUDE_SMART_WINDOW_SIZE,
+        stride_size=_CLAUDE_SMART_STRIDE_SIZE,
+    )
+    if os.environ.get(_DISABLE_OPTIMIZER_ENV) != "0":
+        adapter.apply_optimizer_defaults(
+            script_path=_optimizer_assistant_path(),
+            timeout_seconds=_OPTIMIZER_TIMEOUT_SECONDS,
+        )
+
+    if not banner:
+        hook.emit_continue()
+        return
+
+    sys.stdout.write(
+        json.dumps(
+            {
+                "hookSpecificOutput": {
+                    "hookEventName": "SessionStart",
+                    "additionalContext": banner,
+                }
+            }
+        )
+    )
+    sys.stdout.write("\n")
+
+    try:
+        adapter.mark_stall_notified()
+    except Exception:  # noqa: BLE001 — telemetry must not break session.
+        pass
+
+
+def _optimizer_assistant_path() -> str:
+    executable = Path(sys.executable)
+    suffix = ".exe" if os.name == "nt" else ""
+    return str(executable.with_name(f"claude-smart-optimizer-assistant{suffix}"))