claude-smart 0.2.37 → 0.2.40

package/plugin/src/claude_smart/cli.py

@@ -14,9 +14,8 @@ Exposes the following subcommands:
 - ``learn``: publish unpublished interactions and force reflexio
   extraction now over the active session buffer.
 - ``restart``: stop and restart the reflexio backend + dashboard services
-  (rebuilding the dashboard bundle) so local edits under the ``reflexio``
-  submodule or ``plugin/dashboard/`` take effect without restarting Claude
-  Code.
+  (rebuilding the dashboard bundle) so local Reflexio checkout edits or
+  ``plugin/dashboard/`` edits take effect without restarting Claude Code.
 """
 
 from __future__ import annotations
@@ -30,6 +29,7 @@ import shutil
 import subprocess
 import sys
 import time
+from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -82,6 +82,7 @@ _LOCAL_DATA_NOTICE = (
     "  rm -rf ~/.claude-smart ~/.reflexio\n"
 )
 _INSTALL_FAILURE_MARKER = _STATE_DIR / "install-failed"
+_SERVICE_STATUS_PROBE_FAILED = "probe_failed"
 _DEFAULT_STORAGE_ROOT = _REFLEXIO_DIR / "data"
 _REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / "config_self-host-org.json"
 _LOCAL_STORAGE_ENV = "LOCAL_STORAGE_PATH"
@@ -108,6 +109,94 @@ _COPYTREE_IGNORE = shutil.ignore_patterns(
 )
 
 
+def _windows_path_text(path: str) -> str:
+    """Normalize slashes/case for Windows path checks."""
+    return path.replace("/", "\\").lower()
+
+
+_WINDOWS_SYSTEM_BASH_SUFFIXES = (
+    "\\windows\\system32\\bash.exe",
+    "\\windows\\sysnative\\bash.exe",
+    "\\windows\\syswow64\\bash.exe",
+)
+
+
+def _is_windows_system_bash(path: str) -> bool:
+    normalized = _windows_path_text(path)
+    return normalized.endswith(_WINDOWS_SYSTEM_BASH_SUFFIXES)
+
+
+def _resolve_candidate(candidate: str) -> str | None:
+    expanded = os.path.expandvars(os.path.expanduser(candidate))
+    if os.path.isfile(expanded):
+        return expanded
+    return shutil.which(expanded)
+
+
+def _iter_path_candidates(names: tuple[str, ...]) -> list[str]:
+    found: list[str] = []
+    for raw_dir in os.environ.get("PATH", "").split(os.pathsep):
+        if not raw_dir:
+            continue
+        directory = os.path.expandvars(os.path.expanduser(raw_dir))
+        for name in names:
+            candidate = os.path.join(directory, name)
+            if os.path.isfile(candidate):
+                found.append(candidate)
+    return found
+
+
+def _first_non_system_bash(candidates: Iterable[str]) -> str | None:
+    for candidate in candidates:
+        resolved = _resolve_candidate(candidate)
+        if resolved and not _is_windows_system_bash(resolved):
+            return resolved
+    return None
+
+
+def _resolve_bash() -> str | None:
+    """Resolve a bash executable suitable for running bundled shell scripts.
+
+    Returns:
+        Absolute path to a usable bash, or None when none is available.
+        On Windows, the WSL stub under ``\\Windows\\System32`` (and the
+        ``Sysnative`` / ``SysWOW64`` redirectors) is rejected so that bundled
+        ``*.sh`` scripts run under Git-Bash instead.
+    """
+    if os.name != "nt":
+        return shutil.which("bash")
+
+    sources: list[Iterable[str]] = []
+    bash_env = os.environ.get("BASH", "").strip()
+    if bash_env:
+        sources.append((bash_env,))
+    sources.append(
+        (
+            r"C:\Program Files\Git\bin\bash.exe",
+            r"C:\Program Files (x86)\Git\bin\bash.exe",
+        )
+    )
+    sources.append(_iter_path_candidates(("bash.exe", "bash")))
+    sources.append(("bash.exe", "bash"))
+
+    for source in sources:
+        resolved = _first_non_system_bash(source)
+        if resolved:
+            return resolved
+    return None
+
+
+def _resolve_npm() -> str | None:
+    """Resolve npm, accounting for Windows .cmd/.exe shims."""
+    if os.name == "nt":
+        for candidate in ("npm.cmd", "npm.exe", "npm"):
+            resolved = shutil.which(candidate)
+            if resolved:
+                return resolved
+        return None
+    return shutil.which("npm")
+
+
 def _latest_session_id() -> str | None:
     """Most-recently-modified session JSONL in the state dir. None if none exist."""
     root = state.state_dir()
@@ -201,7 +290,7 @@ def _bootstrap_claude_code_install() -> tuple[bool, str]:
         _force_plugin_root(plugin_root)
     except OSError as exc:
         return False, str(exc)
-    bash = shutil.which("bash")
+    bash = _resolve_bash()
     if not bash:
         return False, "bash is required to bootstrap claude-smart dependencies"
     result = subprocess.run(
@@ -805,7 +894,7 @@ def _register_codex_marketplace(root: Path) -> tuple[bool, str]:
 
 
 def _configure_reflexio_setup() -> bool:
-    """Load setup state from ``~/.reflexio/.env`` without writing local defaults.
+    """Load setup state and ensure local defaults when unmanaged.
 
     Returns:
         bool: Whether read-only mode is enabled.
@@ -850,7 +939,11 @@ def _configure_reflexio_setup() -> bool:
     else:
         os.environ.pop(env_config.REFLEXIO_URL_ENV, None)
         os.environ.pop(env_config.REFLEXIO_API_KEY_ENV, None)
+        os.environ.pop("REFLEXIO_USER_ID", None)
         os.environ.pop("CLAUDE_SMART_MANAGED_SETUP", None)
+        added = env_config.ensure_local_env_defaults(_REFLEXIO_ENV_PATH)
+        if added:
+            sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
     return read_only
 
 
@@ -1251,8 +1344,14 @@ def _run_service(script: Path, subcmd: str) -> int:
     if not script.exists():
         sys.stderr.write(f"error: {script} not found\n")
         return 1
+    bash = _resolve_bash()
+    if not bash:
+        sys.stderr.write(
+            "error: bash is required to run claude-smart service scripts\n"
+        )
+        return 1
     try:
-        subprocess.run([str(script), subcmd], check=True)
+        subprocess.run([bash, str(script), subcmd], check=True)
         return 0
     except subprocess.CalledProcessError as exc:
         return exc.returncode or 1
@@ -1277,10 +1376,16 @@ def _service_status(script: Path, wait_ready_s: float = 3.0) -> str:
     """
     if not script.exists():
         return "script missing"
+    bash = _resolve_bash()
+    if not bash:
+        return _SERVICE_STATUS_PROBE_FAILED
     deadline = time.monotonic() + wait_ready_s
     while True:
         result = subprocess.run(
-            [str(script), "status"], capture_output=True, text=True, check=False
+            [bash, str(script), "status"],
+            capture_output=True,
+            text=True,
+            check=False,
         )
         status = result.stdout.strip() or "unknown"
         if status != "not running" or time.monotonic() >= deadline:
@@ -1305,6 +1410,10 @@ def _is_running_status(status: str) -> bool:
     return status.startswith("running on ")
 
 
+def _is_confirmed_stopped_status(status: str) -> bool:
+    return status == "not running"
+
+
 def _read_dotenv_value(env_path: Path, key: str) -> str | None:
     """Read one simple KEY=VALUE binding from a dotenv file."""
     if not env_path.is_file():
@@ -1507,7 +1616,7 @@ def cmd_restart(args: argparse.Namespace) -> int:
     Stops both long-lived services, optionally rebuilds the dashboard's
     Next.js bundle so source edits under ``plugin/dashboard/`` take effect,
     then starts them again. Useful during local development when iterating
-    on the ``reflexio`` submodule or the dashboard.
+    on the local Reflexio checkout or the dashboard.
 
     Args:
         args (argparse.Namespace): Parsed CLI args. Honors ``args.skip_backend``,
@@ -1536,15 +1645,15 @@ def cmd_restart(args: argparse.Namespace) -> int:
             sys.stderr.write(
                 f"warning: dashboard dir {_DASHBOARD_DIR} missing; skipping rebuild\n"
             )
-        elif not shutil.which("npm"):
+        elif not (npm := _resolve_npm()):
             sys.stderr.write("warning: npm not on PATH; serving previous build\n")
         else:
             next_bin = _DASHBOARD_DIR / "node_modules" / ".bin" / "next"
             if not next_bin.exists():
                 install_cmd = (
-                    ["npm", "ci", "--no-audit", "--no-fund"]
+                    [npm, "ci", "--no-audit", "--no-fund"]
                     if (_DASHBOARD_DIR / "package-lock.json").exists()
-                    else ["npm", "install", "--no-audit", "--no-fund"]
+                    else [npm, "install", "--no-audit", "--no-fund"]
                 )
                 install_label = " ".join(install_cmd)
                 sys.stdout.write(
@@ -1573,10 +1682,11 @@ def cmd_restart(args: argparse.Namespace) -> int:
                 "Rebuilding dashboard (npm run build, may take a minute)…\n"
             )
             try:
-                subprocess.run(["npm", "run", "build"], cwd=_DASHBOARD_DIR, check=True)
-            except subprocess.CalledProcessError as exc:
+                subprocess.run([npm, "run", "build"], cwd=_DASHBOARD_DIR, check=True)
+            except (subprocess.CalledProcessError, OSError) as exc:
+                returncode = getattr(exc, "returncode", 1) or 1
                 sys.stderr.write(
-                    f"error: dashboard build failed (exit {exc.returncode}); "
+                    f"error: dashboard build failed (exit {returncode}); "
                     "not starting dashboard.\n"
                 )
                 if do_backend:
@@ -1585,7 +1695,7 @@ def cmd_restart(args: argparse.Namespace) -> int:
                     sys.stdout.write(
                         f"reflexio backend: {_service_status(_BACKEND_SCRIPT)}\n"
                     )
-                return exc.returncode or 1
+                return returncode
 
     start_rc = 0
     if do_backend:
@@ -1643,7 +1753,14 @@ def cmd_clear_all(args: argparse.Namespace) -> int:
         )
         return 1
 
-    was_running = _is_running_status(_service_status(_BACKEND_SCRIPT, wait_ready_s=0.0))
+    initial_status = _service_status(_BACKEND_SCRIPT, wait_ready_s=0.0)
+    was_running = _is_running_status(initial_status)
+    if not was_running and not _is_confirmed_stopped_status(initial_status):
+        sys.stderr.write(
+            "error: could not confirm reflexio backend is stopped "
+            f"({initial_status}); aborting without deleting data\n"
+        )
+        return 1
     if was_running:
         sys.stdout.write("Stopping reflexio backend…\n")
         stop_rc = _run_service(_BACKEND_SCRIPT, "stop")
@@ -1659,6 +1776,12 @@ def cmd_clear_all(args: argparse.Namespace) -> int:
                 "aborting without deleting data\n"
             )
             return 1
+        if not _is_confirmed_stopped_status(stopped_status):
+            sys.stderr.write(
+                "error: could not confirm reflexio backend stopped "
+                f"({stopped_status}); aborting without deleting data\n"
+            )
+            return 1
 
     removed_targets = 0
     try:

package/plugin/src/claude_smart/context_format.py

@@ -238,6 +238,11 @@ def render_inline_compact_with_registry(
             item = f"{content} (title: {title}"
             if rule_url:
                 item += f"; open: {rule_url}"
+                marker_parts.append(
+                    _markdown_link(
+                        rule_url, _strip_trailing_sentence_punctuation(title)
+                    )
+                )
             item += ")"
         if entry.get("kind") == "profile":
             preference_parts.append(item)
@@ -280,6 +285,17 @@ def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
             "the same linked memory text; keep the link, but do not show the "
             "URL. Skip when unrelated."
         )
+    if marker_parts:
+        marker = f"✨ claude-smart rule applied: {' | '.join(marker_parts)}"
+        separator_instruction = (
+            " Separate multiple linked memories with the visible ` | ` separator."
+            if len(marker_parts) > 1
+            else ""
+        )
+        return _remoteize_citation_instruction(
+            f"If used, copy this final marker exactly with markdown links: "
+            f"`{marker}`.{separator_instruction} Skip when unrelated."
+        )
     return _remoteize_citation_instruction(
         "Only if a listed [cs:...] item materially changes your answer, end "
         "with one final marker like `✨ claude-smart rule applied: "
@@ -368,7 +384,7 @@ def _append_playbook_bullet(
     item_id = cs_cite.rank_id("playbook", rank, real_id)
     title = _title_from_content(content)
     dashboard_url = _dashboard_url("playbook", real_id, source_kind)
-    rule_url = _rule_url(item_id, "playbook")
+    rule_url = _rule_url(item_id, "playbook", real_id, source_kind)
     bullet = f"- [cs:{item_id}] {content}"
     if trigger:
         bullet += f" _(when: {trigger})_"
@@ -407,7 +423,7 @@ def _format_profiles(
         item_id = cs_cite.rank_id("profile", rank, real_id)
         title = _title_from_content(content)
         dashboard_url = _dashboard_url("profile", real_id)
-        rule_url = _rule_url(item_id, "profile")
+        rule_url = _rule_url(item_id, "profile", real_id)
         bullet = f"- [cs:{item_id}] {content}"
         if rule_url:
             bullet += f" _(open: {rule_url})_"
@@ -427,7 +443,7 @@ def _format_profiles(
 
 
 def _dashboard_url(kind: str, real_id: Any, source_kind: str | None = None) -> str:
-    remote_url = _remote_reflexio_page_url(kind)
+    remote_url = _remote_reflexio_item_url(kind, real_id, source_kind)
     if remote_url:
         return remote_url
     if real_id is None:
@@ -442,8 +458,10 @@ def _dashboard_url(kind: str, real_id: Any, source_kind: str | None = None) -> s
     return ""
 
 
-def _rule_url(item_id: str, kind: str) -> str:
-    remote_url = _remote_reflexio_page_url(kind)
+def _rule_url(
+    item_id: str, kind: str, real_id: Any = None, source_kind: str | None = None
+) -> str:
+    remote_url = _remote_reflexio_item_url(kind, real_id, source_kind)
     if remote_url:
         return remote_url
     if not item_id:
@@ -453,6 +471,27 @@ def _rule_url(item_id: str, kind: str) -> str:
     return f"{base}/rules/{encoded_id}"
 
 
+def _remote_reflexio_item_url(
+    kind: str, real_id: Any, source_kind: str | None = None
+) -> str:
+    origin = _remote_reflexio_origin()
+    if not origin:
+        return ""
+    if real_id is None:
+        return _remote_reflexio_page_url(kind)
+    encoded_id = quote(str(real_id), safe="")
+    if kind == "profile":
+        return f"{origin}/profiles?profile_id={encoded_id}"
+    if kind == "playbook":
+        if source_kind == "user_playbook":
+            return (
+                f"{origin}/playbooks?resource=user_playbook&"
+                f"user_playbook_id={encoded_id}"
+            )
+        return f"{origin}/playbooks?agent_playbook_id={encoded_id}"
+    return ""
+
+
 def _remote_reflexio_page_url(kind: str) -> str:
     origin = _remote_reflexio_origin()
     if not origin:
@@ -504,6 +543,12 @@ def _osc8_link(url: str, label: str) -> str:
     return f"\x1b]8;;{url}\x1b\\{label}\x1b]8;;\x1b\\"
 
 
+def _markdown_link(url: str, label: str) -> str:
+    safe_label = label.replace("[", "\\[").replace("]", "\\]")
+    safe_url = url.replace(")", "%29")
+    return f"[{safe_label}]({safe_url})"
+
+
 def _strip_trailing_sentence_punctuation(text: str) -> str:
     return text.rstrip().rstrip(".!?")
 

package/plugin/src/claude_smart/cs_cite.py

@@ -39,7 +39,7 @@ from __future__ import annotations
 
 import re
 from typing import Any
-from urllib.parse import unquote, urlparse
+from urllib.parse import parse_qs, unquote, urlparse
 
 _FINGERPRINT_LEN = 4
 
@@ -287,6 +287,17 @@ def dashboard_url_token(url: str) -> str:
     parsed = urlparse(url)
     path = parsed.path if parsed.scheme else url.split("?", 1)[0].split("#", 1)[0]
     parts = [unquote(part) for part in path.strip("/").split("/") if part]
+    query = parse_qs(parsed.query)
+    if len(parts) == 1 and parts[0] == "profiles":
+        profile_ids = query.get("profile_id") or []
+        return f"route:profile:profile:{profile_ids[0]}" if profile_ids else ""
+    if len(parts) == 1 and parts[0] == "playbooks":
+        user_playbook_ids = query.get("user_playbook_id") or []
+        if query.get("resource") == ["user_playbook"] and user_playbook_ids:
+            return f"route:playbook:user_playbook:{user_playbook_ids[0]}"
+        agent_playbook_ids = query.get("agent_playbook_id") or []
+        if agent_playbook_ids:
+            return f"route:playbook:agent_playbook:{agent_playbook_ids[0]}"
     if len(parts) == 3 and parts[0] == "skills" and parts[1] in {"project", "shared"}:
         source_kind = "user_playbook" if parts[1] == "project" else "agent_playbook"
         return f"route:playbook:{source_kind}:{parts[2]}"

package/plugin/src/claude_smart/env_config.py

@@ -10,6 +10,27 @@ MANAGED_REFLEXIO_URL = "https://www.reflexio.ai/"
 REFLEXIO_URL_ENV = "REFLEXIO_URL"
 REFLEXIO_API_KEY_ENV = "REFLEXIO_API_KEY"
 CLAUDE_SMART_READ_ONLY_ENV = "CLAUDE_SMART_READ_ONLY"
+CLAUDE_SMART_USE_LOCAL_CLI_ENV = "CLAUDE_SMART_USE_LOCAL_CLI"
+CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV = "CLAUDE_SMART_USE_LOCAL_EMBEDDING"
+
+_LOCAL_DEFAULT_ENTRIES = (
+    (
+        "# Route reflexio generation through the local Claude Code CLI",
+        CLAUDE_SMART_USE_LOCAL_CLI_ENV,
+        "1",
+    ),
+    (
+        "# Use the in-process ONNX embedder (chromadb) - no API key for semantic search",
+        CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV,
+        "1",
+    ),
+    (None, CLAUDE_SMART_READ_ONLY_ENV, "0"),
+)
+_LOCAL_MODE_PRUNE_KEYS = {
+    REFLEXIO_URL_ENV,
+    REFLEXIO_API_KEY_ENV,
+    "REFLEXIO_USER_ID",
+}
 
 
 def parse_env_line(line: str) -> tuple[str, str] | None:
@@ -89,6 +110,59 @@ def set_env_vars(path: Path, values: dict[str, str]) -> list[str]:
     return added
 
 
+def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
+    """Create or augment ``~/.reflexio/.env`` for claude-smart local mode.
+
+    Existing active assignments win. This repairs first installs and deleted
+    env files without clobbering explicit user overrides such as
+    ``CLAUDE_SMART_READ_ONLY=1``.
+    """
+    path = path or REFLEXIO_ENV_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        existing = path.read_text()
+    except OSError:
+        existing = ""
+
+    present: set[str] = set()
+    kept_lines: list[str] = []
+    pruned = False
+    for line in existing.splitlines():
+        parsed = parse_env_line(line)
+        if parsed is not None:
+            key, _value = parsed
+            if key in _LOCAL_MODE_PRUNE_KEYS:
+                pruned = True
+                continue
+            present.add(key)
+        kept_lines.append(line)
+
+    additions: list[str] = []
+    added_keys: list[str] = []
+    for comment, key, value in _LOCAL_DEFAULT_ENTRIES:
+        if key in present:
+            continue
+        if comment:
+            additions.append(comment)
+        if key == CLAUDE_SMART_READ_ONLY_ENV:
+            additions.append(f'{key}="{_escape_env_value(value)}"')
+        else:
+            additions.append(f"{key}={_escape_env_value(value)}")
+        added_keys.append(key)
+
+    if additions or pruned:
+        content = "\n".join(kept_lines)
+        if additions:
+            prefix = "" if not content or content.endswith("\n") else "\n"
+            content = content + prefix + "\n".join(additions)
+        content = content + ("\n" if content else "")
+        path.write_text(content, encoding="utf-8")
+    elif not path.exists():
+        path.touch()
+    path.chmod(0o600)
+    return added_keys
+
+
 def env_truthy(name: str) -> bool:
     """Return True when an environment flag is explicitly enabled."""
     return os.environ.get(name, "").strip().lower() in {"1", "true", "yes", "on"}

package/plugin/src/claude_smart/hook_log.py

@@ -79,7 +79,7 @@ def log_event(
             fires against workspace directories.
         internal_skipped (bool): True when ``is_internal_invocation``
             short-circuited the dispatcher (reflexio-internal sub-claude
-            calls, or invocations from inside the reflexio submodule).
+            calls, or invocations from inside a Reflexio checkout).
         handler_status (str): ``"ok"`` for a clean return, ``"unknown_event"``
             when no handler is registered, or ``"raised:<ExcClass>: <msg>"``
             when the handler raised — formatted by ``hook.main``.

package/plugin/src/claude_smart/internal_call.py

@@ -26,9 +26,9 @@ Detection signals, OR'd:
   - 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.
+  - ``payload.cwd`` resolves inside the side-by-side reflexio checkout. Catches
+    direct interactive ``claude`` runs from inside reflexio during local
+    debugging that would otherwise pollute the corpus.
   - Known Codex-internal prompt templates (title generation and home-screen
     suggestions). These are model calls made by Codex itself, not user
     coding turns, and must never be reflected into claude-smart memory.
@@ -61,11 +61,11 @@ _CODEX_SUGGESTIONS_APPS_MARKER = (
     "their connected apps."
 )
 
-# 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.
+# Reflexio usually lives next to claude-smart during local development:
+# <workspace>/claude-smart and <workspace>/reflexio. Anchor relative to this
+# file so the check follows the real checkout if the repo is relocated. In
+# install mode that sibling checkout 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
@@ -73,8 +73,8 @@ _CODEX_SUGGESTIONS_APPS_MARKER = (
 # 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"
-)
+    os.environ.get("CLAUDE_SMART_REFLEXIO_DIR") or _THIS_DIR.parents[3] / "reflexio"
+).resolve()
 
 
 def is_internal_invocation(payload: dict[str, Any]) -> bool:
@@ -86,7 +86,7 @@ def is_internal_invocation(payload: dict[str, Any]) -> bool:
 
     Returns:
         bool: True when the env marker is set or ``cwd`` points inside
-            the reflexio submodule. False otherwise, including when
+            the Reflexio checkout. False otherwise, including when
             ``cwd`` is missing or unresolvable.
     """
     if runtime.is_internal_invocation_env():