@blxzer/cursor-trellis 0.1.0 → 0.1.2

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

@@ -16,10 +16,6 @@ from typing import Any
 ROUTER_VERSION = 2
 
 PLATFORM_CURSOR = "cursor"
-PLATFORM_CLAUDE_CODE = "claude-code"
-PLATFORM_CODEX = "codex"
-PLATFORM_GENERIC = "generic"
-KNOWN_PLATFORMS = {PLATFORM_CURSOR, PLATFORM_CLAUDE_CODE, PLATFORM_CODEX, PLATFORM_GENERIC}
 
 MODALITY_LEXICAL = "lexical"
 MODALITY_STRUCTURAL = "structural"
@@ -193,6 +189,11 @@ def _intent(
     }
 
 
+def classify_codebase_retrieval_intents(query: str) -> list[dict[str, object]]:
+    """Public intent classifier for hooks and dogfood scripts."""
+    return _classify_intents(query)
+
+
 def _classify_intents(query: str) -> list[dict[str, object]]:
     intents: list[dict[str, object]] = []
 
@@ -418,7 +419,7 @@ def _modality_for_intent(
     return [MODALITY_LEXICAL, MODALITY_STRUCTURAL, MODALITY_SEMANTIC]
 
 
-def _token_economy_for_route(route_id: str, platform: str) -> str:
+def _token_economy_for_route(route_id: str) -> str:
     """Return a token-economy label for a given route ID."""
     high_economy = {
         "caller-chain-ast",
@@ -429,9 +430,6 @@ def _token_economy_for_route(route_id: str, platform: str) -> str:
     }
     if route_id in high_economy:
         return TOKEN_ECONOMY_HIGH
-    low_economy = {"exact-rg-primary"}
-    if route_id in low_economy and platform != PLATFORM_CURSOR:
-        return TOKEN_ECONOMY_LOW
     return TOKEN_ECONOMY_MEDIUM
 
 
@@ -445,7 +443,6 @@ def _ordered_routes(
     intents: list[dict[str, object]],
     include_optional_adapters: bool,
     *,
-    platform: str = PLATFORM_GENERIC,
     project_file_count: int | None = None,
 ) -> list[dict[str, object]]:
     ids = {str(item["id"]) for item in intents}
@@ -460,7 +457,6 @@ def _ordered_routes(
     conceptual = INTENT_CONCEPTUAL in ids
     exact_primary_first = preserve or exact
     conceptual_primary = conceptual and not preserve and not exact_primary_first
-    is_cursor = platform == PLATFORM_CURSOR
     large = _large_project(project_file_count)
     semantic_promoted = False
 
@@ -472,7 +468,7 @@ def _ordered_routes(
             **route,
             "order": len(routes) + 1,
             "intentIds": active,
-            "tokenEconomy": _token_economy_for_route(route_id, platform),
+            "tokenEconomy": _token_economy_for_route(route_id),
             "platformNative": route.get("platformNative", False),
         })
 
@@ -546,23 +542,14 @@ def _ordered_routes(
             if policy
             else "Conceptual query without exact signals; semantic recall before exact rg narrowing."
         )
-        if is_cursor:
-            append({
-                "id": "platform-semantic",
-                "role": "semantic",
-                "sourceFamily": "platform-semantic",
-                "commands": ["cursor @codebase or built-in semantic search"],
-                "rationale": semantic_rationale + " (platform-native on Cursor)",
-                "platformNative": True,
-            })
-        else:
-            append({
-                "id": "semantic-fast-context",
-                "role": "semantic",
-                "sourceFamily": "fast-context",
-                "commands": ["fast_context_search query=<question> project_path=<root>"],
-                "rationale": semantic_rationale,
-            })
+        append({
+            "id": "platform-semantic",
+            "role": "semantic",
+            "sourceFamily": "platform-semantic",
+            "commands": ["cursor @codebase or built-in semantic search"],
+            "rationale": semantic_rationale + " (Cursor built-in semantic search)",
+            "platformNative": True,
+        })
         semantic_promoted = True
         append({
             "id": "exact-rg-primary",
@@ -649,41 +636,26 @@ def _ordered_routes(
                 ],
                 "rationale": cg_rationale,
             })
-        if is_cursor:
+        append({
+            "id": "lsp-navigation",
+            "role": "lsp",
+            "sourceFamily": "language-server",
+            "commands": ["definition", "references", "hover"],
+            "rationale": (
+                "Optional editor/LSP navigation when exposed; "
+                "not guaranteed in Agent tool telemetry — prefer Read/Grep/codegraph after candidates exist."
+            ),
+            "platformNative": True,
+        })
+        if not semantic_promoted:
             append({
-                "id": "lsp-navigation",
-                "role": "lsp",
-                "sourceFamily": "language-server",
-                "commands": ["definition", "references", "hover"],
-                "rationale": "LSP via platform-native Cursor features.",
+                "id": "platform-semantic",
+                "role": "semantic",
+                "sourceFamily": "platform-semantic",
+                "commands": ["cursor @codebase or built-in semantic search"],
+                "rationale": "Semantic recall via Cursor built-in codebase search.",
                 "platformNative": True,
             })
-        else:
-            append({
-                "id": "lsp-navigation",
-                "role": "lsp",
-                "sourceFamily": "language-server",
-                "commands": ["definition", "references", "hover"],
-                "rationale": "LSP after candidate symbols exist.",
-            })
-        if not semantic_promoted:
-            if is_cursor:
-                append({
-                    "id": "platform-semantic",
-                    "role": "semantic",
-                    "sourceFamily": "platform-semantic",
-                    "commands": ["cursor @codebase or built-in semantic search"],
-                    "rationale": "Semantic recall via platform-native Cursor search.",
-                    "platformNative": True,
-                })
-            else:
-                append({
-                    "id": "semantic-fast-context",
-                    "role": "semantic",
-                    "sourceFamily": "fast-context",
-                    "commands": ["fast_context_search query=<question> project_path=<root>"],
-                    "rationale": "Semantic recall last; convert to exact rg follow-ups.",
-                })
 
     append({
         "id": "verification-source-git-tests",
@@ -706,8 +678,6 @@ def _fallback_hints(
     intents: list[dict[str, object]],
     include_optional_adapters: bool,
     routes: list[dict[str, object]],
-    *,
-    platform: str = PLATFORM_GENERIC,
 ) -> list[dict[str, object]]:
     hints: list[dict[str, object]] = [
         {
@@ -715,7 +685,6 @@ def _fallback_hints(
             "action": "Codebase retrieval readiness fails; install or expose rg.",
         }
     ]
-    is_cursor = platform == PLATFORM_CURSOR
     if not include_optional_adapters:
         hints.append({
             "when": "codebase-retrieval not selected",
@@ -741,38 +710,22 @@ def _fallback_hints(
     if include_optional_adapters and semantic_route and (
         has_conceptual or int(semantic_route.get("order", 99)) >= 3 or exact_primary
     ):
-        if is_cursor:
-            hints.append({
-                "when": (
-                    "exact rg returns no corroborated file/range candidates "
-                    "(or only trap hits) before final Top-1"
-                ),
-                "action": (
-                    "Use Cursor @codebase or built-in semantic search per platform-semantic route, "
-                    "then narrow with rg on returned keywords and paths."
-                ),
-                "replacesRole": "semantic",
-            })
-        else:
-            hints.append({
-                "when": (
-                    "exact rg returns no corroborated file/range candidates "
-                    "(or only trap hits) before final Top-1"
-                ),
-                "action": (
-                    "Invoke fast_context_search per semantic-fast-context route, then narrow "
-                    "with rg on returned keywords and paths; semantic output remains recall-only "
-                    "until source reads confirm."
-                ),
-                "replacesRole": "semantic",
-            })
+        hints.append({
+            "when": (
+                "exact rg returns no corroborated file/range candidates "
+                "(or only trap hits) before final Top-1"
+            ),
+            "action": (
+                "Use Cursor @codebase or built-in semantic search per platform-semantic route, "
+                "then narrow with rg on returned keywords and paths."
+            ),
+            "replacesRole": "semantic",
+        })
     return hints
 
 
 def _warnings(
     intents: list[dict[str, object]],
-    *,
-    platform: str = PLATFORM_GENERIC,
 ) -> list[str]:
     warnings: list[str] = []
     low = [str(item["id"]) for item in intents if item.get("confidence") == "low"]
@@ -788,9 +741,7 @@ def _warnings(
         and INTENT_EXACT not in ids
         and INTENT_PRESERVE not in ids
     ):
-        semantic_hint = (
-            "platform-semantic" if platform == PLATFORM_CURSOR else "semantic-fast-context"
-        )
+        semantic_hint = "platform-semantic"
         warnings.append(
             f"Conceptual intent without exact signals; {semantic_hint} route promoted in plan. "
             "Convert semantic hits to exact rg follow-ups before final claims."
@@ -802,21 +753,18 @@ def route_codebase_retrieval(
     query: str,
     *,
     codebase_retrieval_selected: bool = True,
-    platform: str = PLATFORM_GENERIC,
     project_file_count: int | None = None,
 ) -> dict[str, object]:
     """Return the shared evidence envelope with router-owned fields populated."""
     normalized = _normalize_query(query)
     include_optional = codebase_retrieval_selected
-    normalized_platform = platform if platform in KNOWN_PLATFORMS else PLATFORM_GENERIC
-
     if not normalized:
         intents = [
             _intent(INTENT_EXACT, "General codebase (exact baseline)", ["empty-query"], "low", True)
         ]
         empty_routes = _ordered_routes(
             intents, include_optional,
-            platform=normalized_platform, project_file_count=project_file_count,
+            project_file_count=project_file_count,
         )
         return {
             "version": ROUTER_VERSION,
@@ -825,17 +773,16 @@ def route_codebase_retrieval(
             "routes": empty_routes,
             "adapterState": [],
             "freshness": [],
-            "fallback": _fallback_hints(intents, include_optional, empty_routes, platform=normalized_platform),
+            "fallback": _fallback_hints(intents, include_optional, empty_routes),
             "warnings": ["Empty query; only baseline exact route is emitted."],
             "verification": _base_verification(),
-            "platform": normalized_platform,
             "projectFileCount": project_file_count,
         }
 
     intents = _classify_intents(normalized)
     routes = _ordered_routes(
         intents, include_optional,
-        platform=normalized_platform, project_file_count=project_file_count,
+        project_file_count=project_file_count,
     )
     return {
         "version": ROUTER_VERSION,
@@ -844,10 +791,9 @@ def route_codebase_retrieval(
         "routes": routes,
         "adapterState": [],
         "freshness": [],
-        "fallback": _fallback_hints(intents, include_optional, routes, platform=normalized_platform),
-        "warnings": _warnings(intents, platform=normalized_platform),
+        "fallback": _fallback_hints(intents, include_optional, routes),
+        "warnings": _warnings(intents),
         "verification": _verification_for_intents(intents),
-        "platform": normalized_platform,
         "projectFileCount": project_file_count,
     }
 
@@ -882,7 +828,6 @@ def resolve_router_envelope(
     *,
     explicit_router: dict[str, Any] | None = None,
     query: str | None = None,
-    platform: str | None = None,
     project_file_count: int | None = None,
 ) -> dict[str, object] | None:
     """Prefer explicit routerEnvelope; otherwise route from query when present."""
@@ -893,10 +838,8 @@ def resolve_router_envelope(
         return None
     caps = load_capabilities_json(repo_root)
     selected = codebase_retrieval_selected_from_capabilities(caps)
-    resolved_platform = platform if platform in KNOWN_PLATFORMS else PLATFORM_GENERIC
     return route_codebase_retrieval(
         normalized,
         codebase_retrieval_selected=selected,
-        platform=resolved_platform,
         project_file_count=project_file_count,
     )

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

@@ -27,6 +27,8 @@ from .packages_context import (
     get_context_packages_text,
     get_context_packages_json,
 )
+from .paths import get_repo_root
+from .project_file_stats import resolve_project_file_count_arg
 from .retrieval_pack_context import output_retrieval_pack_json, read_evidence_input
 from .trellis_config import read_trellis_config
 from .workflow_phase import (
@@ -73,7 +75,7 @@ def main() -> None:
     )
     parser.add_argument(
         "--platform",
-        help="Platform name for --mode phase, e.g. cursor, claude-code. Filters platform-tagged blocks.",
+        help="Platform name for --mode phase, e.g. cursor. Filters platform-tagged blocks.",
     )
     parser.add_argument(
         "--input",
@@ -99,6 +101,15 @@ def main() -> None:
         action="store_true",
         help="Include failed/unavailable evidence in retrieval-pack output when budget allows.",
     )
+    parser.add_argument(
+        "--project-file-count",
+        default="auto",
+        metavar="N|auto",
+        help=(
+            "For --mode retrieval-pack: file count when resolving router envelope "
+            "(default auto from repo root)."
+        ),
+    )
 
     args = parser.parse_args()
 
@@ -128,6 +139,10 @@ def main() -> None:
     elif args.mode == "retrieval-pack":
         try:
             evidence = read_evidence_input(args.input)
+            project_file_count = resolve_project_file_count_arg(
+                args.project_file_count,
+                repo_root=get_repo_root(),
+            )
         except (OSError, json.JSONDecodeError, ValueError) as error:
             parser.exit(1, f"retrieval pack error: {error}\n")
         output_retrieval_pack_json(
@@ -136,7 +151,7 @@ def main() -> None:
             max_estimated_tokens=args.max_estimated_tokens,
             include_diagnostics=args.include_diagnostics,
             pretty=args.json,
-            platform=args.platform,
+            project_file_count=project_file_count,
         )
     else:
         if args.json:

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

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Estimate project file counts for router large-repo heuristics (R-CR-013)."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+DEFAULT_LARGE_PROJECT_THRESHOLD = 2000
+
+# Directories skipped when walking without git (aligned with common VCS ignore patterns).
+_SKIP_DIR_NAMES = frozenset(
+    {
+        ".git",
+        ".trellis",
+        ".venv",
+        "venv",
+        "node_modules",
+        "dist",
+        "build",
+        "out",
+        ".next",
+        "coverage",
+        "__pycache__",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".turbo",
+        ".codegraph",
+        ".cursor",
+    }
+)
+
+
+def count_project_files(repo_root: Path) -> int:
+    """Count tracked + untracked-but-not-ignored files under repo_root (best effort)."""
+    root = repo_root.resolve()
+    git_count = _count_via_git(root)
+    if git_count is not None:
+        return git_count
+    return _count_via_walk(root)
+
+
+def _count_via_git(root: Path) -> int | None:
+    if not (root / ".git").exists():
+        return None
+    try:
+        proc = subprocess.run(
+            ["git", "-C", str(root), "ls-files", "-co", "--exclude-standard"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=120,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    lines = [line for line in proc.stdout.splitlines() if line.strip()]
+    return len(lines)
+
+
+def _count_via_walk(root: Path) -> int:
+    total = 0
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+        if any(part in _SKIP_DIR_NAMES for part in path.relative_to(root).parts):
+            continue
+        total += 1
+    return total
+
+
+def resolve_project_file_count_arg(
+    raw: str | int | None,
+    *,
+    repo_root: Path,
+) -> int | None:
+    """Parse CLI `--project-file-count` (int, `auto`, or omit → auto)."""
+    if raw is None:
+        return count_project_files(repo_root)
+    if isinstance(raw, int):
+        return raw
+    text = str(raw).strip().lower()
+    if text in {"", "auto"}:
+        return count_project_files(repo_root)
+    try:
+        return int(text)
+    except ValueError as error:
+        raise ValueError(
+            f"invalid --project-file-count {raw!r}; use a positive integer or 'auto'"
+        ) from error

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

@@ -236,18 +236,16 @@ def build_adapter_states(
             optional_integration_adapter_state(adapter=adapter, hints=hints)
         )
 
-    # Platform-semantic: replaces fast-context on Cursor
-    platform = string_value(router.get("platform")) if router else None
-    if platform == "cursor":
-        states.append(
-            adapter_state_entry(
-                adapter=ADAPTER_PLATFORM_SEMANTIC,
-                state=STATE_AVAILABLE,
-                required=False,
-                invoked=False,
-                reason="Platform-native semantic search on Cursor (e.g. @codebase); supersedes fast-context",
-            )
+    # Platform-semantic: Cursor built-in semantic search (replaces fast-context)
+    states.append(
+        adapter_state_entry(
+            adapter=ADAPTER_PLATFORM_SEMANTIC,
+            state=STATE_AVAILABLE,
+            required=False,
+            invoked=False,
+            reason="Platform-native semantic search on Cursor (e.g. @codebase); supersedes fast-context",
         )
+    )
 
     states.append(
         adapter_state_entry(