@blxzer/cursor-trellis 0.1.0 → 0.1.2

package/dist/templates/trellis/scripts/codegraph_session_smoke.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Pre-run checks for codegraph index presence (does not start MCP)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from common.paths import get_repo_root
+
+
+def _find_codegraph_dirs(root: Path) -> list[Path]:
+    found: list[Path] = []
+    direct = root / ".codegraph"
+    if direct.is_dir():
+        found.append(direct.resolve())
+    for child in sorted(root.iterdir()):
+        if not child.is_dir():
+            continue
+        nested = child / ".codegraph"
+        if nested.is_dir() and nested.resolve() not in found:
+            found.append(nested.resolve())
+    return found
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Codegraph session smoke (index on disk)")
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=None,
+        help="Workspace root (default: Trellis repo root)",
+    )
+    parser.add_argument("--json", action="store_true", help="Machine-readable report")
+    args = parser.parse_args()
+
+    root = (args.root or get_repo_root()).resolve()
+    indexes = _find_codegraph_dirs(root)
+    ok = len(indexes) > 0
+    payload = {
+        "ok": ok,
+        "workspace_root": str(root),
+        "codegraph_index_paths": [str(p) for p in indexes],
+        "checked_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "mcp_note": (
+            "Cursor: enable codegraph MCP in project settings; this script only checks "
+            "on-disk .codegraph/ directories."
+        ),
+        "run_header_fields": {
+            "codegraph_mcp": "configured|unknown|off",
+            "codegraph_index_path": str(indexes[0]) if indexes else "",
+            "codegraph_smoke_at": "<iso8601>",
+            "codegraph_smoke_ok": ok,
+        },
+    }
+
+    if args.json:
+        print(json.dumps(payload, indent=2))
+    else:
+        if ok:
+            print("Codegraph smoke: PASS")
+            for p in indexes:
+                print(f"  index: {p}")
+        else:
+            print("Codegraph smoke: FAIL — no .codegraph/ under workspace root", file=sys.stderr)
+            print(f"  root: {root}", file=sys.stderr)
+        print(payload["mcp_note"])
+
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
-"""Session-scoped selected task resolution.
-
-The user-facing concept is a live-session "selected task". Trellis stores that
-pointer per AI session/window under `.trellis/.runtime/sessions/`; without a
-stable session key there is no selected task.
-"""
+"""Session-scoped selected task resolution.
+
+The user-facing concept is a live-session "selected task". Trellis stores that
+pointer per AI session/window under `.trellis/.runtime/sessions/`; without a
+stable session key there is no selected task.
+"""
 
 from __future__ import annotations
 
@@ -25,74 +25,43 @@ DIR_RUNTIME = ".runtime"
 DIR_SESSIONS = "sessions"
 DIR_CURSOR_SHELL = "cursor-shell"
 CURSOR_SHELL_TICKET_TTL_SECONDS = 30
-TASK_SESSION_COMMANDS = {"select", "selected", "exit"}
+TASK_SESSION_COMMANDS = {"select", "selected", "exit"}
 
 _SESSION_KEYS = ("session_id", "sessionId", "sessionID")
 _CONVERSATION_KEYS = ("conversation_id", "conversationId", "conversationID")
 _TRANSCRIPT_KEYS = ("transcript_path", "transcriptPath", "transcript")
 _NESTED_KEYS = ("input", "properties", "event", "hook_input", "hookInput")
 _KNOWN_PLATFORMS = {
-    "claude",
-    "codex",
     "cursor",
-    "opencode",
-    "gemini",
-    "droid",
-    "qoder",
-    "codebuddy",
-    "kiro",
-    "copilot",
-    "pi",
 }
 
 _ENV_SESSION_KEYS: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("claude", ("CLAUDE_SESSION_ID", "CLAUDE_CODE_SESSION_ID")),
-    ("codex", ("CODEX_SESSION_ID", "CODEX_THREAD_ID")),
     ("cursor", ("CURSOR_SESSION_ID",)),
-    ("opencode", ("OPENCODE_SESSION_ID", "OPENCODE_SESSIONID", "OPENCODE_RUN_ID")),
-    ("gemini", ("GEMINI_SESSION_ID",)),
-    ("droid", ("FACTORY_SESSION_ID", "DROID_SESSION_ID")),
-    ("qoder", ("QODER_SESSION_ID",)),
-    ("codebuddy", ("CODEBUDDY_SESSION_ID",)),
-    ("kiro", ("KIRO_SESSION_ID",)),
-    ("copilot", ("COPILOT_SESSION_ID", "COPILOT_SESSIONID")),
-    ("pi", ("PI_SESSION_ID", "PI_SESSIONID")),
 )
 _ENV_CONVERSATION_KEYS: tuple[tuple[str, tuple[str, ...]], ...] = (
     ("cursor", ("CURSOR_CONVERSATION_ID", "CURSOR_CONVERSATIONID")),
 )
 _ENV_TRANSCRIPT_KEYS: tuple[tuple[str, tuple[str, ...]], ...] = (
-    ("claude", ("CLAUDE_TRANSCRIPT_PATH",)),
-    ("codex", ("CODEX_TRANSCRIPT_PATH",)),
     ("cursor", ("CURSOR_TRANSCRIPT_PATH",)),
-    ("gemini", ("GEMINI_TRANSCRIPT_PATH",)),
-    ("droid", ("FACTORY_TRANSCRIPT_PATH", "DROID_TRANSCRIPT_PATH")),
-    ("qoder", ("QODER_TRANSCRIPT_PATH",)),
-    ("codebuddy", ("CODEBUDDY_TRANSCRIPT_PATH",)),
 )
-_ENV_PLATFORM_ALIASES = {
-    "claude-code": "claude",
-    "factory": "droid",
-    "factory-ai": "droid",
-    "github-copilot": "copilot",
-}
+_ENV_PLATFORM_ALIASES: dict[str, str] = {}
 
 
 @dataclass(frozen=True)
-class SelectedTask:
-    """Resolved selected task state."""
+class SelectedTask:
+    """Resolved selected task state."""
 
     task_path: str | None
     source_type: str
     context_key: str | None = None
     stale: bool = False
 
-    @property
-    def source(self) -> str:
-        """Human-readable source label."""
-        if self.source_type == "session" and self.context_key:
-            return f"session:{self.context_key}"
-        return self.source_type
+    @property
+    def source(self) -> str:
+        """Human-readable source label."""
+        if self.source_type == "session" and self.context_key:
+            return f"session:{self.context_key}"
+        return self.source_type
 
 
 def normalize_task_ref(task_ref: str) -> str:
@@ -217,7 +186,7 @@ def _lookup_env_context_key(platform_name: str | None) -> str | None:
     Hooks pass `TRELLIS_CONTEXT_ID` to subprocesses they launch, but an AI-run
     shell command can only see session identity if the host platform exports it
     in the command environment. These names are best-effort adapters; if none
-    are present, there is no session-scoped selected task.
+    are present, there is no session-scoped selected task.
     """
     env_platform_name = _env_platform_name(platform_name)
 
@@ -274,7 +243,7 @@ def _task_refs_match(left: str | None, right: str | None, repo_root: Path) -> bo
     return normalize_task_ref(left) == normalize_task_ref(right)
 
 
-def _pending_ticket_matches_args(ticket: dict[str, Any], repo_root: Path) -> bool:
+def _pending_ticket_matches_args(ticket: dict[str, Any], repo_root: Path) -> bool:
     if Path(sys.argv[0]).name != "task.py":
         return False
     args = tuple(sys.argv[1:])
@@ -294,11 +263,11 @@ def _pending_ticket_matches_args(ticket: dict[str, Any], repo_root: Path) -> boo
             continue
         if _string_value(subcommand.get("name")) != command_name:
             continue
-        if command_name != "select":
-            return True
-        task_ref = args[1] if len(args) > 1 else None
-        if _task_refs_match(_string_value(subcommand.get("task_ref")), task_ref, repo_root):
-            return True
+        if command_name != "select":
+            return True
+        task_ref = args[1] if len(args) > 1 else None
+        if _task_refs_match(_string_value(subcommand.get("task_ref")), task_ref, repo_root):
+            return True
 
     return False
 
@@ -446,44 +415,44 @@ def _canonical_task_ref(task_path: str, repo_root: Path) -> str | None:
         return str(full_path)
 
 
-def _selected_from_ref(
-    task_ref: str | None,
-    repo_root: Path,
-    source_type: str,
-    context_key: str | None = None,
-) -> SelectedTask | None:
-    if not task_ref:
-        return None
-    resolved = resolve_task_ref(task_ref, repo_root)
-    stale = resolved is None or not resolved.is_dir()
-    return SelectedTask(task_ref, source_type, context_key, stale)
+def _selected_from_ref(
+    task_ref: str | None,
+    repo_root: Path,
+    source_type: str,
+    context_key: str | None = None,
+) -> SelectedTask | None:
+    if not task_ref:
+        return None
+    resolved = resolve_task_ref(task_ref, repo_root)
+    stale = resolved is None or not resolved.is_dir()
+    return SelectedTask(task_ref, source_type, context_key, stale)
 
 
 def _context_path(repo_root: Path, context_key: str) -> Path:
     return _runtime_sessions_dir(repo_root) / f"{context_key}.json"
 
 
-def resolve_selected_task(
-    repo_root: Path,
-    platform_input: dict[str, Any] | None = None,
-    platform: str | None = None,
-) -> SelectedTask:
-    """Resolve the selected task from explicit session runtime state only.
-
-    A stale session task is returned as stale. Missing context identity or a
-    missing/empty session context returns no selected task. Trellis deliberately
-    does not infer selection from the existence of a single runtime session file;
-    every live session starts with no selected task until the user selects one.
-    """
-    context_key = resolve_context_key(platform_input, platform)
-    if context_key:
-        context = _read_json(_context_path(repo_root, context_key)) or {}
-        task_ref = _string_value(context.get("selected_task"))
-        selected = _selected_from_ref(task_ref, repo_root, "session", context_key)
-        if selected:
-            return selected
-
-    return SelectedTask(None, "none", context_key)
+def resolve_selected_task(
+    repo_root: Path,
+    platform_input: dict[str, Any] | None = None,
+    platform: str | None = None,
+) -> SelectedTask:
+    """Resolve the selected task from explicit session runtime state only.
+
+    A stale session task is returned as stale. Missing context identity or a
+    missing/empty session context returns no selected task. Trellis deliberately
+    does not infer selection from the existence of a single runtime session file;
+    every live session starts with no selected task until the user selects one.
+    """
+    context_key = resolve_context_key(platform_input, platform)
+    if context_key:
+        context = _read_json(_context_path(repo_root, context_key)) or {}
+        task_ref = _string_value(context.get("selected_task"))
+        selected = _selected_from_ref(task_ref, repo_root, "session", context_key)
+        if selected:
+            return selected
+
+    return SelectedTask(None, "none", context_key)
 
 
 def _utc_now() -> str:
@@ -512,17 +481,17 @@ def _context_metadata(
     return metadata
 
 
-def set_selected_task(
-    task_path: str,
-    repo_root: Path,
-    platform_input: dict[str, Any] | None = None,
-    platform: str | None = None,
-) -> SelectedTask | None:
-    """Set the selected task in session scope.
-
-    Returns None when no context key is available; callers should surface a
-    user-facing error that explains how to provide session identity.
-    """
+def set_selected_task(
+    task_path: str,
+    repo_root: Path,
+    platform_input: dict[str, Any] | None = None,
+    platform: str | None = None,
+) -> SelectedTask | None:
+    """Set the selected task in session scope.
+
+    Returns None when no context key is available; callers should surface a
+    user-facing error that explains how to provide session identity.
+    """
     canonical = _canonical_task_ref(task_path, repo_root)
     if canonical is None:
         return None
@@ -531,32 +500,32 @@ def set_selected_task(
     if not context_key:
         return None
 
-    context_path = _context_path(repo_root, context_key)
-    context = _read_json(context_path) or {}
-    context.update(_context_metadata(platform_input, platform, context_key))
-    context["selected_task"] = canonical
-    context.pop("current_task", None)
-    context.setdefault("current_run", None)
-    if not _write_json(context_path, context):
-        return None
-    return SelectedTask(canonical, "session", context_key)
-
-
-def clear_selected_task(
-    repo_root: Path,
-    platform_input: dict[str, Any] | None = None,
-    platform: str | None = None,
-) -> SelectedTask:
-    """Clear the selected task by deleting the current session context file."""
-    context_key = resolve_context_key(platform_input, platform)
-    if not context_key:
-        return SelectedTask(None, "none")
-
-    previous = resolve_selected_task(repo_root, platform_input, platform)
-    context_path = _context_path(repo_root, context_key)
-    if context_path.is_file():
-        _remove_file(context_path)
-    return previous
+    context_path = _context_path(repo_root, context_key)
+    context = _read_json(context_path) or {}
+    context.update(_context_metadata(platform_input, platform, context_key))
+    context["selected_task"] = canonical
+    context.pop("current_task", None)
+    context.setdefault("current_run", None)
+    if not _write_json(context_path, context):
+        return None
+    return SelectedTask(canonical, "session", context_key)
+
+
+def clear_selected_task(
+    repo_root: Path,
+    platform_input: dict[str, Any] | None = None,
+    platform: str | None = None,
+) -> SelectedTask:
+    """Clear the selected task by deleting the current session context file."""
+    context_key = resolve_context_key(platform_input, platform)
+    if not context_key:
+        return SelectedTask(None, "none")
+
+    previous = resolve_selected_task(repo_root, platform_input, platform)
+    context_path = _context_path(repo_root, context_key)
+    if context_path.is_file():
+        _remove_file(context_path)
+    return previous
 
 
 def clear_task_from_sessions(task_path: str, repo_root: Path) -> int:
@@ -572,12 +541,12 @@ def clear_task_from_sessions(task_path: str, repo_root: Path) -> int:
 
     for session_path in sessions_dir.glob("*.json"):
         context = _read_json(session_path) or {}
-        current = (
-            _string_value(context.get("selected_task"))
-            or _string_value(context.get("current_task"))
-        )
-        if not current:
-            continue
+        current = (
+            _string_value(context.get("selected_task"))
+            or _string_value(context.get("current_task"))
+        )
+        if not current:
+            continue
         current_ref = _canonical_task_ref(current, repo_root) or normalize_task_ref(current)
         if current_ref != target:
             continue
@@ -587,21 +556,21 @@ def clear_task_from_sessions(task_path: str, repo_root: Path) -> int:
     return cleared
 
 
-def get_selected_task_source(
-    repo_root: Path,
-    platform_input: dict[str, Any] | None = None,
-    platform: str | None = None,
-) -> tuple[str, str | None, str | None]:
-    """Return (`source_type`, `context_key`, `task_path`) for selected task."""
-    active = resolve_selected_task(repo_root, platform_input, platform)
-    return active.source_type, active.context_key, active.task_path
-
-
-# Internal compatibility aliases. User-facing commands and generated guidance
-# use selected-task wording, but keeping these names avoids a broad one-shot
-# rewrite of imports that are not part of the public command surface.
-ActiveTask = SelectedTask
-resolve_active_task = resolve_selected_task
-set_active_task = set_selected_task
-clear_active_task = clear_selected_task
-get_current_task_source = get_selected_task_source
+def get_selected_task_source(
+    repo_root: Path,
+    platform_input: dict[str, Any] | None = None,
+    platform: str | None = None,
+) -> tuple[str, str | None, str | None]:
+    """Return (`source_type`, `context_key`, `task_path`) for selected task."""
+    active = resolve_selected_task(repo_root, platform_input, platform)
+    return active.source_type, active.context_key, active.task_path
+
+
+# Internal compatibility aliases. User-facing commands and generated guidance
+# use selected-task wording, but keeping these names avoids a broad one-shot
+# rewrite of imports that are not part of the public command surface.
+ActiveTask = SelectedTask
+resolve_active_task = resolve_selected_task
+set_active_task = set_selected_task
+clear_active_task = clear_selected_task
+get_current_task_source = get_selected_task_source