devcouncil 0.3.1 → 0.4.0

package/src/devcouncil/integrations/actions.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Any
 
 from devcouncil.integrations.check import build_integration_check_report
+from devcouncil.executors.agent_registry import GEMINI_DEPRECATION_MESSAGE
 
 logger = logging.getLogger(__name__)
 
@@ -18,6 +19,7 @@ VALID_INTEGRATION_TARGETS = {
     "gemini",
     "claude",
     "cursor",
+    "grok",
     "opencode",
     "antigravity",
     "agy",
@@ -104,6 +106,11 @@ def apply_integration_target(
         add_result(name, code == 0, None, "MCP registration command exited " + str(code))
 
     def apply_project_file(name: str) -> None:
+        if name == "grok":
+            ok = integrate._configure_grok(root, apply=True)
+            path = integrate._grok_config_path(root)
+            add_result(name, ok, path if path.exists() else None, "Grok MCP integration configured." if ok else "Grok MCP integration failed.")
+            return
         writers = {
             "cursor": integrate._write_cursor_config,
             "opencode": integrate._write_opencode_config,
@@ -126,7 +133,8 @@ def apply_integration_target(
 
     def apply_hooks() -> None:
         integrate._configure_native_hooks(root, "all", apply=True, claude_write_gate=claude_write_gate)
-        add_result("hooks", True, None, "Native hook files configured.")
+        integrate._install_git_map_hooks(root, apply=True)
+        add_result("hooks", True, None, "Native hook files configured (incl. git map --if-stale).")
 
     def apply_claude_assets() -> None:
         try:
@@ -134,16 +142,21 @@ def apply_integration_target(
         except (ValueError, FileNotFoundError, OSError) as exc:
             add_result("claude-assets", False, None, f"Claude asset setup failed: {exc}")
             return
+        integrate._record_claude_config(
+            root,
+            scope=claude_scope,
+            write_gate=claude_write_gate,
+        )
         add_result("claude-assets", True, None, f"Claude assets installed ({len(written)} file(s)).")
 
     if normalized == "all":
-        for name in ("codex", "gemini", "claude"):
+        for name in ("claude", "codex"):
             apply_first_party(name)
         # Batch the per-tool config.yaml record updates (project files, aider,
         # and native hooks) into one load/save cycle. _batched_raw_config is
         # re-entrant, so apply_hooks()'s own batching participates in this one.
         with integrate._batched_raw_config(root):
-            for name in ("cursor", "opencode", "antigravity", "warp"):
+            for name in ("cursor", "grok", "opencode", "antigravity", "warp"):
                 apply_project_file(name)
             apply_aider()
             if include_hooks:
@@ -153,8 +166,18 @@ def apply_integration_target(
             # the claude CLI is on PATH, since these are plain files.
             apply_claude_assets()
     elif normalized in {"codex", "gemini", "claude"}:
+        if normalized == "gemini":
+            warnings.append(GEMINI_DEPRECATION_MESSAGE)
+            integrate.console.print(f"[yellow]{GEMINI_DEPRECATION_MESSAGE}[/yellow]")
         apply_first_party(normalized)
-    elif normalized in {"cursor", "opencode", "antigravity", "warp"}:
+        if include_hooks and normalized == "codex":
+            integrate._configure_native_hooks(root, "codex", apply=True)
+            add_result("codex-hooks", True, root / ".codex" / "hooks.json", "Codex native hooks configured; review trust with /hooks.")
+        elif include_hooks and normalized == "claude":
+            integrate._install_claude_hooks(root, write_gate=claude_write_gate)
+            apply_claude_assets()
+            add_result("claude-hooks", True, root / ".claude" / "settings.local.json", "Claude native hooks configured.")
+    elif normalized in {"cursor", "grok", "opencode", "antigravity", "warp"}:
         apply_project_file(normalized)
     elif normalized == "aider":
         apply_aider()

package/src/devcouncil/integrations/check.py

@@ -6,6 +6,7 @@ import json
 import shutil
 import subprocess
 import sys
+import tomllib
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -13,12 +14,15 @@ from typing import Any
 from devcouncil.executors.agent_registry import (
     CODING_CLI_INTEGRATION_INFO,
     CODING_CLI_VERSION_COMMANDS,
+    DEPRECATED_CODING_CLIS,
+    GEMINI_DEPRECATION_MESSAGE,
     detect_available_coding_cli,
     resolve_automated_executor,
     resolve_coding_cli_executable,
     resolve_coding_cli_probe_order,
 )
 from devcouncil.utils.subprocess_env import clean_subprocess_env
+from devcouncil.utils.json_persist import read_json
 
 
 @dataclass(frozen=True)
@@ -58,6 +62,7 @@ CODING_CLI_CHECK_LABELS: dict[str, str] = {
     "gemini": "Gemini CLI",
     "claude": "Claude Code",
     "cursor": "Cursor",
+    "grok": "Grok Build",
     "opencode": "OpenCode",
     "antigravity": "Google Antigravity CLI",
     "warp": "Warp / Oz",
@@ -127,19 +132,123 @@ def _load_json_file(path: Path) -> dict[str, Any]:
     if not path.exists():
         return {}
     try:
-        loaded = json.loads(path.read_text(encoding="utf-8")) or {}
+        loaded = read_json(path) or {}
     except json.JSONDecodeError:
         return {}
     return loaded if isinstance(loaded, dict) else {}
 
 
+def _claude_config_status(project_root: Path) -> tuple[str, bool, list[str]]:
+    settings_path = project_root / ".claude" / "settings.local.json"
+    assets_dir = project_root / ".claude" / "commands" / "devcouncil"
+    data = _load_json_file(settings_path)
+    status_line = data.get("statusLine") if data else {}
+    status_line_ok = (
+        isinstance(status_line, dict)
+        and "hook claude-statusline" in str(status_line.get("command", ""))
+    )
+    mcp_ok = "devcouncil" in (data.get("enabledMcpjsonServers") or [])
+    assets_ok = assets_dir.is_dir() and (assets_dir / "status.md").exists()
+    ok = (status_line_ok or mcp_ok) and assets_ok
+    paths = [str(settings_path)]
+    if assets_ok:
+        paths.append(str(assets_dir))
+    if ok:
+        return "ok", False, paths
+    if not settings_path.exists() and not assets_ok:
+        return "missing", True, paths
+    return "drifted", True, paths
+
+
+def _codex_config_status(project_root: Path) -> tuple[str, bool, list[str]]:
+    """Check the client-persisted MCP registration, not just repo hook files."""
+    executable = resolve_coding_cli_executable(project_root, "codex")
+    logical_path = "codex mcp:devcouncil"
+    if not executable:
+        return "missing", True, [logical_path]
+    try:
+        result = subprocess.run(
+            [executable, "mcp", "get", "devcouncil", "--json"],
+            cwd=project_root,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=10,
+            env=clean_subprocess_env(),
+        )
+        data = json.loads(result.stdout) if result.returncode == 0 else {}
+    except (OSError, subprocess.TimeoutExpired, json.JSONDecodeError):
+        data = {}
+
+    from devcouncil.integrations.clients.common import _server_args
+
+    expected = _server_args(project_root)
+    transport = data.get("transport") if isinstance(data, dict) else {}
+    transport = transport if isinstance(transport, dict) else {}
+    env = transport.get("env") or {}
+    ok = (
+        data.get("enabled") is True
+        and transport.get("type") == "stdio"
+        and transport.get("command") == expected[0]
+        and transport.get("args") == expected[1:]
+        and isinstance(env, dict)
+        and env.get("DEVCOUNCIL_PROJECT_ROOT") == str(project_root)
+    )
+    return ("ok" if ok else "drifted"), not ok, [logical_path, str(project_root / ".codex" / "hooks.json")]
+
+
+def _codex_hook_schema_status(project_root: Path) -> tuple[bool, str]:
+    """Validate the repository Codex hook schema and canonical feature flag."""
+    hooks_path = project_root / ".codex" / "hooks.json"
+    config_path = project_root / ".codex" / "config.toml"
+    try:
+        data = read_json(hooks_path)
+        config = tomllib.loads(config_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, tomllib.TOMLDecodeError) as exc:
+        return False, f"Invalid Codex hook configuration: {exc}"
+    hooks = data.get("hooks") if isinstance(data, dict) else None
+    required = {"PreToolUse", "PostToolUse", "SessionStart", "Stop", "SubagentStop"}
+    if not isinstance(hooks, dict) or not required.issubset(hooks):
+        missing = sorted(required - set(hooks or {}))
+        return False, f"Missing Codex hook events: {', '.join(missing)}"
+    for event, groups in hooks.items():
+        if not isinstance(groups, list):
+            return False, f"Codex hook event {event} must contain a list"
+        for group in groups:
+            for hook in group.get("hooks", []) if isinstance(group, dict) else []:
+                if not isinstance(hook, dict) or not str(hook.get("name", "")).startswith("devcouncil-"):
+                    continue
+                timeout = hook.get("timeout")
+                if not isinstance(timeout, int) or not 1 <= timeout <= 600:
+                    return False, f"Codex hook {hook.get('name')} timeout must be 1..600 seconds"
+                if "--client codex" not in str(hook.get("command", "")):
+                    return False, f"Codex hook {hook.get('name')} does not select the Codex schema"
+    features = config.get("features") if isinstance(config, dict) else {}
+    if not isinstance(features, dict) or features.get("hooks") is not True:
+        return False, "[features].hooks must be true"
+    if "codex_hooks" in features:
+        return False, "Deprecated [features].codex_hooks is still present"
+    return True, f"{hooks_path}; hook trust must be reviewed in Codex with /hooks"
+
+
 def _cursor_config_status(project_root: Path) -> tuple[str, bool, list[str]]:
     path = project_root / ".cursor" / "mcp.json"
     data = _load_json_file(path)
     server = ((data.get("mcpServers") or {}).get("devcouncil") or {}) if data else {}
+    command = server.get("command")
+    # Accept bare ``devcouncil`` or an absolute/relative path whose basename is
+    # ``devcouncil`` (project venv). Both are valid; absolute paths are preferred
+    # when Cursor's shell PATH does not include the project venv.
+    from pathlib import Path as _Path
+
+    name_ok = False
+    if isinstance(command, str) and command.strip():
+        name = _Path(command.replace("\\", "/")).name.lower()
+        name_ok = name in {"devcouncil", "devcouncil.exe"}
     ok = (
         server.get("type") == "stdio"
-        and server.get("command") == "devcouncil"
+        and name_ok
         and server.get("args") == ["mcp-server"]
         and (server.get("env") or {}).get("DEVCOUNCIL_PROJECT_ROOT") == str(project_root)
     )
@@ -148,6 +257,22 @@ def _cursor_config_status(project_root: Path) -> tuple[str, bool, list[str]]:
     return ("missing" if not path.exists() else "drifted"), True, [str(path)]
 
 
+def _grok_config_status(project_root: Path) -> tuple[str, bool, list[str]]:
+    path = project_root / ".grok" / "config.toml"
+    if not path.exists():
+        return "missing", True, [str(path)]
+    text = path.read_text(encoding="utf-8")
+    ok = (
+        "[mcp_servers.devcouncil]" in text
+        and "devcouncil" in text
+        and "mcp-server" in text
+        and str(project_root) in text
+    )
+    if ok:
+        return "ok", False, [str(path)]
+    return "drifted", True, [str(path)]
+
+
 def _opencode_config_status(project_root: Path) -> tuple[str, bool, list[str]]:
     path = project_root / "opencode.json"
     data = _load_json_file(path)
@@ -203,8 +328,14 @@ def integration_capability_rows(project_root: Path) -> list[dict[str, object]]:
         config_status = "not_applicable"
         fixable = bool(info.mcp or info.hooks or info.launcher_shim)
         paths: list[str] = []
-        if client == "cursor":
+        if client == "codex":
+            config_status, fixable, paths = _codex_config_status(project_root)
+        elif client == "cursor":
             config_status, fixable, paths = _cursor_config_status(project_root)
+        elif client == "grok":
+            config_status, fixable, paths = _grok_config_status(project_root)
+        elif client == "claude":
+            config_status, fixable, paths = _claude_config_status(project_root)
         elif client == "opencode":
             config_status, fixable, paths = _opencode_config_status(project_root)
         elif client == "antigravity":
@@ -235,20 +366,28 @@ def integration_capability_rows(project_root: Path) -> list[dict[str, object]]:
 def _hook_config_references_devcouncil(path: Path) -> bool | None:
     """Return whether a client hook config still wires DevCouncil's gate.
 
-    ``True``  -> the file exists and references ``devcouncil`` somewhere in its hooks.
+    ``True``  -> the file exists and still invokes the DevCouncil pre/post-tool gate.
     ``False`` -> the file exists but no longer references it (tampered/disarmed).
     ``None``  -> the file does not exist (client was never integrated here).
 
     Reads the raw text rather than parsing each client's bespoke schema so it works
     uniformly across JSON hook files and is resilient to format drift; the goal is a
-    tamper tripwire, not full schema validation."""
+    tamper tripwire, not full schema validation.
+
+    Accepts either an explicit ``devcouncil`` marker (named hooks / ``devcouncil`` CLI)
+    or the project-venv ``dev hook …`` command Cursor installs (no named hook id).
+    """
     if not path.exists():
         return None
     try:
         text = path.read_text(encoding="utf-8")
     except OSError:
         return False
-    return "devcouncil" in text.lower()
+    lower = text.lower()
+    if "devcouncil" in lower:
+        return True
+    # Cursor flat hooks: ``…/bin/dev hook pre-tool-use --client cursor …``
+    return "hook pre-tool-use" in lower or "hook post-tool-use" in lower
 
 
 def _hook_config_tamper_targets(project_root: Path) -> list[tuple[str, Path]]:
@@ -257,6 +396,7 @@ def _hook_config_tamper_targets(project_root: Path) -> list[tuple[str, Path]]:
         ("Codex", project_root / ".codex" / "hooks.json"),
         ("Gemini", project_root / ".gemini" / "settings.json"),
         ("Cursor", project_root / ".cursor" / "hooks.json"),
+        ("Grok", project_root / ".grok" / "hooks" / "devcouncil.json"),
     ]
 
 
@@ -273,9 +413,9 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
             failures += 1
 
     def add_optional(ok: bool, name: str, details: str) -> None:
-        if strict and not ok:
-            add(False, name, details)
-            return
+        # Coding CLIs (and similar optional probes) stay informational even under
+        # --strict. Absence is never a failure; --strict still elevates real
+        # project/integration defects via add() / add_soft().
         rows.append(IntegrationCheckRow(name=name, status="ok" if ok else "missing", details=details))
 
     def add_skip(name: str, details: str) -> None:
@@ -284,20 +424,29 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
     root = project_root.expanduser().resolve()
     detected = detect_available_coding_cli(root)
     add((root / ".devcouncil").exists(), "Project state", str(root / ".devcouncil"))
-    devcouncil_path = shutil.which("devcouncil")
+    from devcouncil.integrations.clients.common import resolve_dev_executable
+
+    devcouncil_path = resolve_dev_executable(root)
+    resolved_dev = Path(devcouncil_path).exists() or shutil.which(devcouncil_path) is not None
+    devcouncil_launch = [devcouncil_path] if resolved_dev else [sys.executable, "-m", "devcouncil"]
     add(
-        devcouncil_path is not None or Path(sys.executable).exists(),
+        resolved_dev or Path(sys.executable).exists(),
         "devcouncil CLI",
-        devcouncil_path or f"{sys.executable} -m devcouncil",
+        " ".join(devcouncil_launch),
     )
 
-    devcouncil_launch = [devcouncil_path] if devcouncil_path else [sys.executable, "-m", "devcouncil"]
     code, output = integrate._run_capture([*devcouncil_launch, "--help"])
     add(code == 0, "devcouncil command", output.splitlines()[0] if output else "No output")
 
-    for client in resolve_coding_cli_probe_order(root):
+    probe_order = resolve_coding_cli_probe_order(root)
+    for client in probe_order:
         cli_ok, cli_details = probe_coding_cli_version(client)
         add_optional(cli_ok, CODING_CLI_CHECK_LABELS.get(client, client), cli_details)
+    for client in sorted(DEPRECATED_CODING_CLIS):
+        if client in probe_order:
+            continue
+        label = CODING_CLI_CHECK_LABELS.get(client, client)
+        add_skip(label, GEMINI_DEPRECATION_MESSAGE)
 
     rec_ok, rec_details = recommended_executor_status(root, detected)
     add_optional(rec_ok, "Recommended coding CLI", rec_details)
@@ -320,7 +469,7 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
         hooks_ok = False
         if cursor_hooks.exists():
             try:
-                hooks_data = json.loads(cursor_hooks.read_text(encoding="utf-8")) or {}
+                hooks_data = read_json(cursor_hooks) or {}
                 hooks_ok = "preToolUse" in hooks_data.get("hooks", {})
             except json.JSONDecodeError:
                 hooks_ok = False
@@ -329,6 +478,29 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
             "Cursor hooks",
             str(cursor_hooks) if hooks_ok else "Run dev integrate hooks --apply --tool cursor.",
         )
+        from devcouncil.integrations.clients.cursor import probe_cursor_auth
+
+        auth_ok, auth_details = probe_cursor_auth()
+        # Authentication for an optional, non-selected client is machine/user
+        # state, not a broken repository integration.  Keep it informational even
+        # under --strict, matching missing optional CLI handling.
+        add_optional(auth_ok, "Cursor auth", auth_details)
+
+    grok_hooks = root / ".grok" / "hooks" / "devcouncil.json"
+    grok_enabled = bool(raw_config.get("integrations", {}).get("grok", {}).get("enabled"))
+    if grok_enabled or grok_hooks.exists():
+        hooks_ok = False
+        if grok_hooks.exists():
+            try:
+                hooks_data = read_json(grok_hooks) or {}
+                hooks_ok = "PreToolUse" in hooks_data.get("hooks", {})
+            except json.JSONDecodeError:
+                hooks_ok = False
+        add(
+            hooks_ok,
+            "Grok hooks",
+            str(grok_hooks) if hooks_ok else "Run dev integrate hooks --apply --tool grok (then /hooks-trust in Grok).",
+        )
 
     opencode_config = integrate._opencode_config_path(root)
     opencode_enabled = bool(raw_config.get("integrations", {}).get("opencode", {}).get("enabled"))
@@ -338,7 +510,7 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
         plugin_registered = False
         if plugin_ok and opencode_config.exists():
             try:
-                opencode_data = json.loads(opencode_config.read_text(encoding="utf-8")) or {}
+                opencode_data = read_json(opencode_config) or {}
                 plugin_registered = (
                     f"./.devcouncil/integrations/{integrate.OPENCODE_HOOK_PLUGIN_NAME}"
                     in (opencode_data.get("plugin") or [])
@@ -387,10 +559,30 @@ def build_integration_check_report(project_root: Path, *, strict: bool = False)
             str(hook_path) if references else f"{hook_path} no longer references devcouncil (tampered/disarmed).",
         )
 
+    codex_hooks_path = root / ".codex" / "hooks.json"
+    if codex_hooks_path.exists():
+        codex_schema_ok, codex_schema_details = _codex_hook_schema_status(root)
+        add(codex_schema_ok, "Codex hook schema", codex_schema_details)
+        add_skip("Codex hook trust", "Open Codex in this project and run /hooks after any hook change.")
+
+    from devcouncil.integrations.clients.common import check_hook_dev_executable
+
+    hook_exe_ok, hook_exe_details = check_hook_dev_executable(root)
+    if common_recorded_hook_exe(root) is not None:
+        add(hook_exe_ok, "Hook `dev` executable", hook_exe_details)
+    else:
+        add_skip("Hook `dev` executable", hook_exe_details)
+
     recommended = resolve_automated_executor(root, None) if detected else None
     return IntegrationCheckReport(tuple(rows), recommended, failures)
 
 
+def common_recorded_hook_exe(project_root: Path) -> str | None:
+    from devcouncil.integrations.clients.common import recorded_hook_dev_executable
+
+    return recorded_hook_dev_executable(project_root)
+
+
 def integration_status_summary(project_root: Path) -> dict[str, Any]:
     from devcouncil.app.config import load_config
 
@@ -402,11 +594,13 @@ def integration_status_summary(project_root: Path) -> dict[str, Any]:
         default_executor = execution.default_executor
         stream_cli_output = execution.stream_cli_output
         cursor_resume_mode = execution.cursor_resume_mode
+        grok_resume_mode = execution.grok_resume_mode
         custom_probe_order = list(execution.coding_cli_probe_order)
     except Exception:
         default_executor = "manual"
         stream_cli_output = False
         cursor_resume_mode = "off"
+        grok_resume_mode = "off"
         custom_probe_order = []
 
     resolved = resolve_automated_executor(project_root, None) if detected or default_executor != "manual" else "manual"
@@ -422,5 +616,6 @@ def integration_status_summary(project_root: Path) -> dict[str, Any]:
         "custom_probe_order": custom_probe_order,
         "stream_cli_output": stream_cli_output,
         "cursor_resume_mode": cursor_resume_mode,
+        "grok_resume_mode": grok_resume_mode,
         "capabilities": integration_capability_rows(project_root),
     }