@blxzer/cursor-trellis 0.2.7 → 0.2.9

package/dist/templates/trellis/local/patch_wpelc8.py

@@ -17,6 +17,7 @@ from trellis_task_models_config import (
 )
 
 MARKER = "/*TRELLIS_B2_WPeLc8*/"
+INJECT_NEEDLE = "});return!UbAQWn||"
 
 
 def _repo_root(start: Path) -> Path:
@@ -111,28 +112,43 @@ def resolve_model_layers(bundle_dir: Path, config: dict, providers_path: Path) -
     return resolve_slots_to_slugs(merged, providers_path)
 
 
-def resolve_extension_js(bundle_dir: Path, config: dict) -> Path:
+def configured_slot_map(bundle_dir: Path, config: dict) -> dict[str, list[str]]:
+    """Non-secret role → [primary, fallback, …] from JSON5 only (no providers.json read)."""
+    user_path = resolve_user_models_path(config)
+    project_path = resolve_project_models_path(bundle_dir, config)
+    user_slots = extract_raw_slots(load_task_models_document(user_path))
+    project_slots = (
+        extract_raw_slots(load_task_models_document(project_path))
+        if project_path
+        else {}
+    )
+    return _merge_slot_maps(user_slots, project_slots)
+
+
+def _extension_candidates(config: dict) -> list[Path]:
     for key in ("extensionJs", "extension_js"):
         if isinstance(config.get(key), str) and config[key].strip():
-            return Path(config[key].strip()).expanduser()
+            return [Path(config[key].strip()).expanduser()]
     env = os.environ.get("TRELLIS_CURSOR2PLUS_EXTENSION", "").strip()
     if env:
-        return Path(env).expanduser()
+        return [Path(env).expanduser()]
     if sys.platform == "win32":
         local = os.environ.get("LOCALAPPDATA", "")
-        candidates = [
+        return [
             Path(local) / "Programs" / "cursor" / "resources" / "app" / "extensions" / "cursor2plus" / "dist" / "extension.js",
             Path(r"D:\cursor\resources\app\extensions\cursor2plus\dist\extension.js"),
         ]
-    elif sys.platform == "darwin":
-        candidates = [
+    if sys.platform == "darwin":
+        return [
             Path("/Applications/Cursor.app/Contents/Resources/app/extensions/cursor2plus/dist/extension.js"),
         ]
-    else:
-        candidates = [
-            Path.home() / ".local" / "share" / "cursor" / "resources" / "app" / "extensions" / "cursor2plus" / "dist" / "extension.js",
-        ]
-    for c in candidates:
+    return [
+        Path.home() / ".local" / "share" / "cursor" / "resources" / "app" / "extensions" / "cursor2plus" / "dist" / "extension.js",
+    ]
+
+
+def resolve_extension_js(bundle_dir: Path, config: dict) -> Path:
+    for c in _extension_candidates(config):
         if c.is_file():
             return c
     raise SystemExit(
@@ -140,6 +156,13 @@ def resolve_extension_js(bundle_dir: Path, config: dict) -> Path:
     )
 
 
+def try_resolve_extension_js(bundle_dir: Path, config: dict) -> Path | None:
+    for c in _extension_candidates(config):
+        if c.is_file():
+            return c
+    return None
+
+
 def build_inject_block(model_map: dict[str, str]) -> str:
     if not model_map:
         raise SystemExit(
@@ -164,15 +187,27 @@ def find_wpelc8_body(source: str) -> tuple[int, int]:
     return start, end
 
 
+def probe_wpelc8_compat(source: str) -> dict[str, str]:
+    """Non-exiting WPeLc8 / inject-anchor probe for --check-compat and smoke."""
+    start = source.find("function WPeLc8(")
+    if start < 0:
+        return {"wpelc8": "not_locatable", "inject_anchor": "unknown", "end_anchor": "unknown"}
+    end = source.find("async function*o4ZNpa", start)
+    if end < 0:
+        return {"wpelc8": "locatable", "inject_anchor": "unknown", "end_anchor": "missing"}
+    fn = source[start:end]
+    anchor = "present" if INJECT_NEEDLE in fn else "missing"
+    return {"wpelc8": "locatable", "inject_anchor": anchor, "end_anchor": "present"}
+
+
 def apply_patch(source: str, inject: str) -> str:
     start, end = find_wpelc8_body(source)
     fn = source[start:end]
     if MARKER in fn:
         fn = remove_patch_from_fn(fn)
-    needle = "});return!UbAQWn||"
-    if needle not in fn:
-        raise SystemExit(f"inject anchor missing: {needle!r}")
-    fn_new = fn.replace(needle, f"}});{inject}return!UbAQWn||", 1)
+    if INJECT_NEEDLE not in fn:
+        raise SystemExit(f"inject anchor missing: {INJECT_NEEDLE!r}")
+    fn_new = fn.replace(INJECT_NEEDLE, f"}});{inject}return!UbAQWn||", 1)
     return source[:start] + fn_new + source[end:]
 
 
@@ -240,14 +275,80 @@ def cmd_bootstrap(bundle_dir: Path) -> None:
     print("Next: in Cursor Agent, run skill trellis-cursor2plus-setup", file=sys.stderr)
 
 
+def cmd_check_compat(bundle_dir: Path, config: dict) -> int:
+    extension = try_resolve_extension_js(bundle_dir, config)
+    result: dict[str, object] = {
+        "extension": str(extension) if extension else None,
+        "patch_marker_present": False,
+        "wpelc8": "unknown",
+        "inject_anchor": "unknown",
+        "end_anchor": "unknown",
+    }
+    if extension is None:
+        result["status"] = "unknown"
+        result["hint"] = (
+            "extension.js not found — set extensionJs in config.local.json or run --bootstrap; "
+            "manual verification required"
+        )
+        print(json.dumps(result, indent=2, sort_keys=True))
+        return 2
+
+    source = extension.read_text(encoding="utf-8", errors="ignore")
+    result["patch_marker_present"] = MARKER in source
+    probe = probe_wpelc8_compat(source)
+    result.update(probe)
+
+    wpelc8 = probe["wpelc8"]
+    anchor = probe["inject_anchor"]
+    end_anchor = probe.get("end_anchor", "unknown")
+
+    if wpelc8 == "not_locatable" or anchor == "missing":
+        result["status"] = "fail"
+        result["hint"] = (
+            "WPeLc8 or inject anchor not found after Cursor/Cursor++ upgrade — "
+            "re-run patch with --apply --approve or revert to inherit-parent"
+        )
+    elif wpelc8 == "unknown" or anchor == "unknown" or end_anchor == "unknown":
+        result["status"] = "unknown"
+        result["hint"] = "Locator uncertain — manually verify extension.js after any upgrade"
+    else:
+        result["status"] = "ok"
+        result["hint"] = "WPeLc8 and inject anchor locatable"
+
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["status"] == "ok" else (1 if result["status"] == "fail" else 2)
+
+
 def main() -> None:
-    ap = argparse.ArgumentParser(description="Trellis Cursor++ WPeLc8 model map")
-    ap.add_argument("--revert", action="store_true")
-    ap.add_argument("--dry-run", action="store_true")
-    ap.add_argument("--bootstrap", action="store_true")
-    ap.add_argument("--explain", action="store_true")
-    ap.add_argument("--list-models", action="store_true")
-    ap.add_argument("--print-map", action="store_true")
+    ap = argparse.ArgumentParser(
+        description="Trellis Cursor++ WPeLc8 model map (Method 2.5)",
+        epilog=(
+            "Read-only: --print-map, --check-compat. "
+            "Write: --apply --approve (or --revert). "
+            "Never runs in CI by default."
+        ),
+    )
+    ap.add_argument("--revert", action="store_true", help="Remove Trellis patch from extension.js")
+    ap.add_argument("--apply", action="store_true", help="Apply patch to extension.js")
+    ap.add_argument(
+        "--approve",
+        action="store_true",
+        help="Explicit operator approval (required for --apply writes)",
+    )
+    ap.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="With --apply: validate patch without writing extension.js",
+    )
+    ap.add_argument("--bootstrap", action="store_true", help="Create config.local.json with extension path")
+    ap.add_argument("--explain", action="store_true", help="Explain trellis-task-models.json5 keys")
+    ap.add_argument("--list-models", action="store_true", help="List models from providers.json catalog")
+    ap.add_argument("--print-map", action="store_true", help="Dry-run: print resolved slug map (no file writes)")
+    ap.add_argument(
+        "--check-compat",
+        action="store_true",
+        help="Check WPeLc8 locatability in current extension.js (no file writes)",
+    )
     args = ap.parse_args()
 
     bundle_dir = Path(__file__).resolve().parent
@@ -259,39 +360,62 @@ def main() -> None:
         return
 
     config = _load_config(bundle_dir)
+
+    if args.check_compat:
+        raise SystemExit(cmd_check_compat(bundle_dir, config))
+
     providers_path = resolve_providers_json(config)
 
     if args.list_models:
         cmd_list_models(providers_path)
         return
 
-    model_map, notes = resolve_model_layers(bundle_dir, config, providers_path)
-    if notes:
-        print("resolve:", file=sys.stderr)
-        for line in notes:
-            print(line, file=sys.stderr)
-    if any("ERROR" in line for line in notes):
-        raise SystemExit(1)
+    needs_map = args.print_map or args.apply or args.revert
+    model_map: dict[str, str] = {}
+    notes: list[str] = []
+    if needs_map and not args.revert:
+        model_map, notes = resolve_model_layers(bundle_dir, config, providers_path)
+        if notes:
+            print("resolve:", file=sys.stderr)
+            for line in notes:
+                print(line, file=sys.stderr)
+        if any("ERROR" in line for line in notes):
+            raise SystemExit(1)
 
     if args.print_map:
         print(json.dumps(model_map, indent=2, sort_keys=True))
         return
 
-    extension = resolve_extension_js(bundle_dir, config)
-    source = extension.read_text(encoding="utf-8", errors="ignore")
     if args.revert:
+        extension = resolve_extension_js(bundle_dir, config)
+        source = extension.read_text(encoding="utf-8", errors="ignore")
         new = remove_patch(source)
-    else:
+        extension.write_text(new, encoding="utf-8", newline="\n")
+        print("wrote", extension)
+        return
+
+    if args.apply:
+        if not args.approve and not args.dry_run:
+            print(
+                "refused: --apply writes extension.js and requires explicit --approve "
+                "(use --dry-run to validate without writing)",
+                file=sys.stderr,
+            )
+            raise SystemExit(1)
+        extension = resolve_extension_js(bundle_dir, config)
+        source = extension.read_text(encoding="utf-8", errors="ignore")
         inject = build_inject_block(model_map)
         new = apply_patch(source, inject)
-
-    if args.dry_run:
-        print("ok", "revert" if args.revert else "patch", "delta", len(new) - len(source))
+        if args.dry_run:
+            print("ok patch delta", len(new) - len(source))
+            return
+        extension.write_text(new, encoding="utf-8", newline="\n")
+        print("wrote", extension)
         return
 
-    extension.write_text(new, encoding="utf-8", newline="\n")
-    print("wrote", extension)
+    ap.print_help()
+    raise SystemExit(2)
 
 
 if __name__ == "__main__":
-    main()
+    main()

package/dist/templates/trellis/local/smoke.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Cursor++ local bundle smoke check — whitelist metadata only, no secret reads."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+from patch_wpelc8 import (
+    MARKER,
+    _load_config,
+    configured_slot_map,
+    probe_wpelc8_compat,
+    try_resolve_extension_js,
+)
+
+CAVEATS = [
+    "Cursor++ is third-party; reverse-engineering is version-bound",
+    "Never reads BYOK provider catalog file contents",
+    "Patch is operator-only; not part of CI or default Trellis workflow",
+    "Re-verify after any Cursor or Cursor++ upgrade",
+]
+
+
+def detect_env() -> tuple[str, str | None]:
+    env_flag = os.environ.get("TRELLIS_CURSOR_BYOK", "").strip()
+    if env_flag == "1":
+        return "byok", "TRELLIS_CURSOR_BYOK=1"
+    if env_flag == "0":
+        return "native", "TRELLIS_CURSOR_BYOK=0"
+
+    routes = Path.home() / ".ccursor" / "routes.json"
+    if routes.is_file():
+        try:
+            data = json.loads(routes.read_text(encoding="utf-8"))
+            byok = data.get("byokMode")
+            if byok in (1, "1", True):
+                return "byok", "routes.json:byokMode"
+            if byok in (0, "0", False):
+                return "native", "routes.json:byokMode"
+        except (OSError, json.JSONDecodeError, TypeError):
+            pass
+    return "unknown", None
+
+
+def detect_patch_status(bundle_dir: Path, config: dict) -> tuple[str, dict[str, object]]:
+    extension = try_resolve_extension_js(bundle_dir, config)
+    meta: dict[str, object] = {"extension": str(extension) if extension else None}
+    if extension is None:
+        return "not-applied", meta
+
+    source = extension.read_text(encoding="utf-8", errors="ignore")
+    marker_present = MARKER in source
+    meta["patch_marker_present"] = marker_present
+    probe = probe_wpelc8_compat(source)
+    meta.update(probe)
+
+    if not marker_present:
+        return "not-applied", meta
+
+    if probe["wpelc8"] == "not_locatable" or probe["inject_anchor"] == "missing":
+        return "stale", meta
+    if probe["wpelc8"] == "unknown" or probe["inject_anchor"] == "unknown":
+        return "stale", meta
+    return "applied", meta
+
+
+def main() -> int:
+    bundle_dir = Path(__file__).resolve().parent
+    config = _load_config(bundle_dir)
+    env, env_source = detect_env()
+    patch_status, patch_meta = detect_patch_status(bundle_dir, config)
+    slots = configured_slot_map(bundle_dir, config)
+
+    report = {
+        "env": env,
+        "env_source": env_source,
+        "patch_status": patch_status,
+        "patch_meta": patch_meta,
+        "current_map": {
+            "configured_roles": {
+                role: {"candidates": names} for role, names in sorted(slots.items())
+            },
+            "note": "Role names from user JSON5 config only; slugs not resolved (no provider catalog read)",
+        },
+        "caveats": CAVEATS,
+    }
+    print(json.dumps(report, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/templates/trellis/scripts/common/codebase_retrieval_router.py

@@ -14,8 +14,8 @@ from pathlib import Path
 from typing import Any
 
 from .cursor_retrieval_env import (
-    ENV_BYOK,
     detect_cursor_retrieval_env,
+    is_byok_conservative,
     semantic_route_spec,
 )
 
@@ -716,7 +716,7 @@ def _fallback_hints(
             "replacesRole": "semantic",
         })
     cenv = cursor_env or detect_cursor_retrieval_env()
-    if cenv == ENV_BYOK:
+    if is_byok_conservative(cenv):
         hints.append({
             "when": "built-in @codebase / SemanticSearch not in agent tool list",
             "action": (

package/dist/templates/trellis/scripts/common/cursor_retrieval_env.py

@@ -75,12 +75,26 @@ def is_byok(env: CursorRetrievalEnv | None = None) -> bool:
     return (env or detect_cursor_retrieval_env()) == ENV_BYOK
 
 
+def is_byok_conservative(env: CursorRetrievalEnv | None = None) -> bool:
+    """Conservative semantic routing: BYOK plus unknown (no routes.json / ambiguous byokMode)."""
+    resolved = env or detect_cursor_retrieval_env()
+    return resolved == ENV_BYOK or resolved == ENV_UNKNOWN
+
+
 def semantic_route_spec(cursor_env: CursorRetrievalEnv) -> dict[str, object]:
     """platform-semantic route fields for conceptual / optional semantic slots."""
-    if cursor_env == ENV_BYOK:
+    if is_byok_conservative(cursor_env):
+        unknown_caveat = (
+            " Unknown cursorEnv: conservative fast-context primary (same as BYOK)."
+            if cursor_env == ENV_UNKNOWN
+            else ""
+        )
         return {
             "commands": ["fast_context_search (fast-context MCP)"],
-            "rationale_suffix": " Cursor++ BYOK: built-in semantic unavailable; fast-context MCP primary.",
+            "rationale_suffix": (
+                " Cursor++ BYOK: built-in semantic unavailable; fast-context MCP primary."
+                + unknown_caveat
+            ),
             "platformNative": False,
             "semanticBackend": "fast-context-mcp",
         }