claude-smart 0.2.37 → 0.2.39

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(
@@ -1251,8 +1340,12 @@ 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 +1370,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 +1404,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 +1610,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 +1639,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 +1676,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 +1689,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 +1747,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 +1770,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/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():