devcouncil 0.3.0 → 0.4.0

package/src/devcouncil/integrations/clients/common.py

@@ -0,0 +1,332 @@
+
+"""Shared integration utilities."""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+
+import yaml
+from rich.console import Console
+
+from devcouncil.executors.agent_registry import (
+    CODING_CLI_INTEGRATION_INFO,
+    normalize_agent_name,
+)
+from devcouncil.utils.subprocess_env import clean_subprocess_env
+
+console = Console()
+logger = logging.getLogger(__name__)
+
+OPENCODE_HOOK_PLUGIN_NAME = "opencode_devcouncil_plugin.mjs"
+SUPPORTED_HOOK_TOOLS = ("claude", "codex", "cursor", "grok")
+# Clients whose native hook installers wire Stop/SubagentStop handlers.
+STOP_HOOK_TOOLS = frozenset({"claude", "codex"})
+
+
+def seed_stop_gate_assist_if_unset(config: dict) -> None:
+    """Default ``execution.stop_gate.mode`` to ``assist`` when hooks are installed.
+
+    Code default remains ``off`` (``StopGateConfig.mode``); integrate/first-run setup
+    for Stop-hook clients opts into assistive warnings without blocking completion.
+    """
+    execution = config.setdefault("execution", {})
+    stop_gate = execution.setdefault("stop_gate", {})
+    if not isinstance(stop_gate, dict):
+        stop_gate = {}
+        execution["stop_gate"] = stop_gate
+    if not stop_gate.get("mode"):
+        stop_gate["mode"] = "assist"
+    stop_gate.setdefault("check_claims", True)
+    stop_gate.setdefault("verify_active_task", True)
+
+# Recorded when hooks are installed so `dev integrate hooks --check` can detect drift
+# between a stale global CLI and the project venv.
+HOOK_DEV_EXECUTABLE_REL = Path(".devcouncil") / "cache" / "hook_dev_executable"
+
+
+def resolve_dev_executable(project_root: Path) -> str:
+    """Resolve the ``dev`` CLI to invoke from hooks (project venv first, then PATH).
+
+    Preferring the project ``.venv`` avoids a globally installed stale ``dev`` silently
+    fighting the working tree over cache versions and map schema.
+    """
+    root = project_root.expanduser().resolve()
+    candidates: list[Path] = []
+    if sys.platform == "win32":
+        candidates.extend(
+            [
+                root / ".venv" / "Scripts" / "dev.exe",
+                root / ".venv" / "Scripts" / "devcouncil.exe",
+                root / "venv" / "Scripts" / "dev.exe",
+            ]
+        )
+    else:
+        candidates.extend(
+            [
+                root / ".venv" / "bin" / "dev",
+                root / ".venv" / "bin" / "devcouncil",
+                root / "venv" / "bin" / "dev",
+                root / "venv" / "bin" / "devcouncil",
+            ]
+        )
+    for candidate in candidates:
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return str(candidate.resolve())
+    for name in ("dev", "devcouncil"):
+        found = shutil.which(name)
+        if found:
+            return found
+    return "dev"
+
+
+def record_hook_dev_executable(project_root: Path, executable: str | None = None) -> Path:
+    """Persist the resolved ``dev`` path used in installed hook commands."""
+    root = project_root.expanduser().resolve()
+    path = root / HOOK_DEV_EXECUTABLE_REL
+    path.parent.mkdir(parents=True, exist_ok=True)
+    resolved = executable or resolve_dev_executable(root)
+    path.write_text(resolved + "\n", encoding="utf-8")
+    return path
+
+
+def recorded_hook_dev_executable(project_root: Path) -> str | None:
+    path = project_root.expanduser().resolve() / HOOK_DEV_EXECUTABLE_REL
+    if not path.is_file():
+        return None
+    text = path.read_text(encoding="utf-8").strip()
+    return text or None
+
+
+def check_hook_dev_executable(project_root: Path) -> tuple[bool, str]:
+    """Compare recorded hook executable against the currently resolved one."""
+    root = project_root.expanduser().resolve()
+    current = resolve_dev_executable(root)
+    recorded = recorded_hook_dev_executable(root)
+    if recorded is None:
+        return True, f"No recorded hook executable (current: {current})"
+    if Path(recorded).resolve() == Path(current).resolve() or recorded == current:
+        return True, f"Hook executable matches: {current}"
+    return False, f"Hook executable mismatch: recorded={recorded} current={current}"
+
+
+def _project_root(path: str | Path | None) -> Path:
+    root = Path(path or ".").expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+
+    set_log_dir(root)
+    return root
+
+def _warn_if_verify_only(client: str) -> None:
+    """Print a prominent containment warning when wiring a verify-only client.
+
+    Verify-only clients have no native pre-tool-use hook, so DevCouncil cannot block a
+    forbidden write or command before it happens — it is only caught post-hoc at verify
+    time. Surface this loudly so users don't assume hard containment."""
+    info = CODING_CLI_INTEGRATION_INFO.get(normalize_agent_name(client))
+    if info is not None and not info.hooks:
+        console.print(
+            f"[bold yellow]Warning ({info.label}): No pre-action containment — "
+            "forbidden writes/commands are caught only at verify time.[/bold yellow]"
+        )
+
+def _server_args(project_root: Path) -> list[str]:
+    """Return the exact MCP server command clients should persist.
+
+    Project integrations must execute the checkout they were generated from.  A
+    bare ``devcouncil`` command can resolve to an older global installation and
+    silently serve a different schema than the working tree.
+    """
+    return [resolve_dev_executable(project_root), "mcp-server"]
+
+_PENDING_RAW_CONFIG: dict | None = None
+
+@contextmanager
+def _batched_raw_config(project_root: Path):
+    global _PENDING_RAW_CONFIG
+    # Re-entrant: if a batch is already active, participate in it instead of
+    # starting a nested load/save (which would otherwise reset the shared
+    # buffer to None on inner exit and drop the outer batch's mutations).
+    if _PENDING_RAW_CONFIG is not None:
+        yield
+        return
+    _PENDING_RAW_CONFIG = _load_raw_config(project_root)
+    try:
+        yield
+    finally:
+        # Persist whatever mutations accumulated, even if an inner installer raised
+        # partway through — matching the old per-installer save, which committed each
+        # installer's change immediately rather than dropping the whole batch on a
+        # mid-loop failure.
+        pending = _PENDING_RAW_CONFIG
+        _PENDING_RAW_CONFIG = None
+        if pending is not None:
+            _save_raw_config(project_root, pending)
+
+def _mutate_raw_config(project_root: Path, mutate) -> None:
+    if _PENDING_RAW_CONFIG is not None:
+        mutate(_PENDING_RAW_CONFIG)
+        return
+    config = _load_raw_config(project_root)
+    mutate(config)
+    _save_raw_config(project_root, config)
+
+def _load_json_strict(path: Path, label: str = "JSON") -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8")) or {}
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"{path} is not valid JSON. Fix the {label} config before rerunning integration setup.") from exc
+
+def _format_command(command: list[str]) -> str:
+    if sys.platform == "win32":
+        return " ".join(_quote_powershell_arg(arg) for arg in command)
+    return shlex.join(command)
+
+def _quote_powershell_arg(arg: str) -> str:
+    if arg == "":
+        return "''"
+    special_chars = set(" \t\r\n'\"{}[](),;|&<>")
+    if not any(char in special_chars for char in arg):
+        return arg
+    return "'" + arg.replace("'", "''") + "'"
+
+def _probe_mcp_tools(root: Path, *, timeout_seconds: float = 30.0) -> list[str]:
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    import asyncio
+    import os
+
+    async def _list_tools() -> list[str]:
+        env = os.environ.copy()
+        env["DEVCOUNCIL_PROJECT_ROOT"] = str(root)
+        command = _server_args(root)
+        params = StdioServerParameters(
+            command=command[0],
+            args=command[1:],
+            cwd=str(root),
+            env=env,
+        )
+        async with stdio_client(params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                tools = await session.list_tools()
+                return [tool.name for tool in tools.tools]
+
+    async def _list_tools_with_deadline() -> list[str]:
+        # A wedged server process would otherwise block `dev integrate check`
+        # indefinitely; the caller treats TimeoutError as a failed probe.
+        return await asyncio.wait_for(_list_tools(), timeout=timeout_seconds)
+
+    return asyncio.run(_list_tools_with_deadline())
+
+_CLI_RUN_TIMEOUT_SECONDS = 120
+
+def _run(command: list[str]) -> int:
+    executable = shutil.which(command[0])
+    if not executable:
+        return 127
+    resolved = [executable, *command[1:]]
+    use_shell = sys.platform == "win32" and Path(executable).suffix.lower() in {".bat", ".cmd", ".ps1"}
+    invocation = subprocess.list2cmdline(resolved) if use_shell else resolved
+    try:
+        result = subprocess.run(
+            invocation,
+            text=True,
+            shell=use_shell,
+            timeout=_CLI_RUN_TIMEOUT_SECONDS,
+            env=clean_subprocess_env(),
+        )
+    except subprocess.TimeoutExpired:
+        return 124
+    except (FileNotFoundError, OSError):
+        return 127
+    return result.returncode
+
+def _run_capture(command: list[str], timeout: int = 10) -> tuple[int, str]:
+    executable = shutil.which(command[0])
+    if not executable:
+        return 127, f"{command[0]} not found on PATH"
+
+    resolved = [executable, *command[1:]]
+    use_shell = sys.platform == "win32" and Path(executable).suffix.lower() in {".bat", ".cmd", ".ps1"}
+    invocation = subprocess.list2cmdline(resolved) if use_shell else resolved
+    try:
+        result = subprocess.run(
+            invocation,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            shell=use_shell,
+            timeout=timeout,
+            env=clean_subprocess_env(),
+        )
+    except subprocess.TimeoutExpired:
+        return 124, "timed out"
+    except (FileNotFoundError, OSError) as exc:
+        return 127, f"{command[0]} could not be executed: {exc}"
+    return result.returncode, (result.stdout + result.stderr).strip()
+
+def _config_path(project_root: Path) -> Path:
+    return project_root / ".devcouncil" / "config.yaml"
+
+def _load_raw_config(project_root: Path) -> dict:
+    path = _config_path(project_root)
+    if not path.exists():
+        return {}
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+def _save_raw_config(project_root: Path, config: dict) -> None:
+    path = _config_path(project_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(config, sort_keys=False), encoding="utf-8")
+
+def _load_json(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8")) or {}
+    except json.JSONDecodeError:
+        return {}
+
+def _save_json(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    from devcouncil.utils.json_persist import write_json
+
+    write_json(path, data)
+
+def _print_command(tool: str, command: list[str], apply: bool):
+    if apply:
+        console.print(f"[cyan]Configuring {tool} MCP integration...[/cyan]")
+    else:
+        console.print(f"[bold]{tool}[/bold]")
+        console.print(_format_command(command), soft_wrap=True)
+
+def _configure(tool: str, command: list[str], apply: bool) -> bool:
+    executable = command[0]
+    if not shutil.which(executable):
+        console.print(f"[yellow]{tool} CLI not found on PATH. Install it first, then rerun this command.[/yellow]")
+        console.print(_format_command(command), soft_wrap=True)
+        return False
+
+    _print_command(tool, command, apply)
+    if not apply:
+        return True
+
+    code = _run(command)
+    if code == 0:
+        console.print(f"[green]{tool} integration configured.[/green]")
+        return True
+
+    console.print(f"[red]{tool} integration command failed with exit code {code}.[/red]")
+    console.print("You can rerun it manually:")
+    console.print(_format_command(command), soft_wrap=True)
+    return False

package/src/devcouncil/integrations/clients/cursor.py

@@ -0,0 +1,164 @@
+"""Cursor integration adapter."""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from pathlib import Path
+
+from devcouncil.executors.agent_registry import resolve_cursor_agent_executable
+from devcouncil.integrations.clients import common as _common
+
+_project_root = _common._project_root
+_warn_if_verify_only = _common._warn_if_verify_only
+_server_args = _common._server_args
+_format_command = _common._format_command
+_quote_powershell_arg = _common._quote_powershell_arg
+_run = _common._run
+_run_capture = _common._run_capture
+_config_path = _common._config_path
+_load_raw_config = _common._load_raw_config
+_save_raw_config = _common._save_raw_config
+_load_json = _common._load_json
+_save_json = _common._save_json
+_load_json_strict = _common._load_json_strict
+_mutate_raw_config = _common._mutate_raw_config
+_batched_raw_config = _common._batched_raw_config
+_probe_mcp_tools = _common._probe_mcp_tools
+_print_command = _common._print_command
+_configure = _common._configure
+
+console = _common.console
+
+
+def _cursor_executable() -> str | None:
+    return resolve_cursor_agent_executable()
+
+
+def _cursor_config_path(project_root: Path) -> Path:
+    return project_root / ".cursor" / "mcp.json"
+
+
+def _cursor_mcp_command(project_root: Path) -> str:
+    """Prefer the project venv ``devcouncil`` binary for Cursor MCP stdio.
+
+    Absolute paths survive Cursor sessions that lack the project venv on PATH;
+    bare ``devcouncil`` still works when PATH is set. Status checks accept both.
+    """
+    from devcouncil.integrations.clients.common import resolve_dev_executable
+
+    resolved = Path(resolve_dev_executable(project_root))
+    name = resolved.name.lower()
+    if name in {"dev", "dev.exe"}:
+        sibling = resolved.with_name("devcouncil.exe" if name.endswith(".exe") else "devcouncil")
+        if sibling.is_file():
+            return str(sibling)
+    if name in {"devcouncil", "devcouncil.exe"}:
+        return str(resolved)
+    # Fall back to PATH name when no local binary exists.
+    return "devcouncil"
+
+
+def _cursor_mcp_config(project_root: Path) -> dict:
+    root = project_root.expanduser().resolve()
+    if os.name == "nt":
+        venv_bin = root / ".venv" / "Scripts"
+    else:
+        venv_bin = root / ".venv" / "bin"
+    path_prefix = str(venv_bin) if venv_bin.is_dir() else ""
+    existing_path = os.environ.get("PATH", "/usr/bin:/bin")
+    env_path = f"{path_prefix}{os.pathsep}{existing_path}" if path_prefix else existing_path
+    return {
+        "mcpServers": {
+            "devcouncil": {
+                "type": "stdio",
+                "command": _cursor_mcp_command(root),
+                "args": ["mcp-server"],
+                "env": {
+                    "DEVCOUNCIL_PROJECT_ROOT": str(root),
+                    "PATH": env_path,
+                },
+            }
+        }
+    }
+
+
+def _write_cursor_config(project_root: Path) -> Path:
+    path = _cursor_config_path(project_root)
+    data = _load_json_strict(path, "Cursor")
+    mcp_servers = data.setdefault("mcpServers", {})
+    mcp_servers["devcouncil"] = _cursor_mcp_config(project_root)["mcpServers"]["devcouncil"]
+    _save_json(path, data)
+    return path
+
+
+def _record_cursor_config(project_root: Path) -> None:
+    def mutate(config: dict) -> None:
+        cursor = config.setdefault("integrations", {}).setdefault("cursor", {})
+        cursor.update({
+            "enabled": True,
+            "config_path": str(_cursor_config_path(project_root).relative_to(project_root)),
+        })
+
+    _mutate_raw_config(project_root, mutate)
+
+
+def probe_cursor_auth() -> tuple[bool, str]:
+    """Probe Cursor CLI auth via agent status/about."""
+    executable = _cursor_executable()
+    if not executable:
+        return False, "agent/cursor-agent not found on PATH"
+    if os.environ.get("CURSOR_API_KEY"):
+        return True, "CURSOR_API_KEY set (CI headless auth)"
+    for subcommand in ("status", "about"):
+        code, output = _run_capture([executable, subcommand])
+        if code == 0 and output.strip():
+            first = output.strip().splitlines()[0]
+            return True, first
+    return False, "Run agent login or set CURSOR_API_KEY for CI headless auth"
+
+
+def probe_cursor_mcp_list() -> tuple[bool, str]:
+    executable = _cursor_executable()
+    if not executable:
+        return False, "agent/cursor-agent not found on PATH"
+    code, output = _run_capture([executable, "mcp", "list"])
+    if code != 0:
+        return False, output.strip() or "agent mcp list failed"
+    return True, output.strip().splitlines()[0] if output.strip() else "MCP servers listed"
+
+
+def _configure_cursor(project_root: Path, apply: bool) -> bool:
+    path = _cursor_config_path(project_root)
+    config = _cursor_mcp_config(project_root)
+    executable = _cursor_executable() or "agent"
+    if not apply:
+        console.print("[bold]Cursor[/bold]")
+        console.print(f"Project MCP config file: [dim]{path}[/dim]")
+        console.print(json.dumps(config, separators=(",", ":")), soft_wrap=True)
+        console.print(f"Verify in Cursor CLI with: [dim]{executable} mcp list[/dim]")
+        auth_ok, auth_details = probe_cursor_auth()
+        if auth_ok:
+            console.print(f"Auth: [green]{auth_details}[/green]")
+        else:
+            console.print(f"Auth: [yellow]{auth_details}[/yellow]")
+        if not os.environ.get("CURSOR_API_KEY"):
+            console.print("CI headless: export [dim]CURSOR_API_KEY[/dim] (see Cursor headless docs)")
+        return True
+
+    if not shutil.which("cursor") and not _cursor_executable():
+        console.print("[yellow]Cursor CLI not found on PATH. Project MCP config will still be available to Cursor.[/yellow]")
+    try:
+        written = _write_cursor_config(project_root)
+    except ValueError as exc:
+        console.print(f"[red]{exc}[/red]")
+        return False
+    _record_cursor_config(project_root)
+    console.print(f"[green]Cursor MCP config written:[/green] {written}")
+    mcp_ok, mcp_details = probe_cursor_mcp_list()
+    if mcp_ok:
+        console.print(f"[dim]MCP probe: {mcp_details}[/dim]")
+    auth_ok, auth_details = probe_cursor_auth()
+    if not auth_ok:
+        console.print(f"[yellow]Auth check: {auth_details}[/yellow]")
+    return True

package/src/devcouncil/integrations/clients/gemini.py

@@ -0,0 +1,49 @@
+"""Gemini integration adapter (deprecated).
+
+Google replaced Gemini CLI with Antigravity CLI. Prefer ``dev integrate antigravity --apply``.
+Explicit ``dev integrate gemini`` remains for compatibility only.
+"""
+from __future__ import annotations
+
+import warnings
+from pathlib import Path
+
+from devcouncil.executors.agent_registry import GEMINI_DEPRECATION_MESSAGE
+from devcouncil.integrations.clients import common as _common
+
+_project_root = _common._project_root
+_warn_if_verify_only = _common._warn_if_verify_only
+_server_args = _common._server_args
+_format_command = _common._format_command
+_quote_powershell_arg = _common._quote_powershell_arg
+_run = _common._run
+_run_capture = _common._run_capture
+_config_path = _common._config_path
+_load_raw_config = _common._load_raw_config
+_save_raw_config = _common._save_raw_config
+_load_json = _common._load_json
+_save_json = _common._save_json
+_load_json_strict = _common._load_json_strict
+_mutate_raw_config = _common._mutate_raw_config
+_batched_raw_config = _common._batched_raw_config
+_probe_mcp_tools = _common._probe_mcp_tools
+_print_command = _common._print_command
+_configure = _common._configure
+
+console = _common.console
+
+
+def _gemini_command(project_root: Path, scope: str) -> list[str]:
+    warnings.warn(GEMINI_DEPRECATION_MESSAGE, DeprecationWarning, stacklevel=2)
+    console.print(f"[yellow]{GEMINI_DEPRECATION_MESSAGE}[/yellow]")
+    return [
+        "gemini",
+        "mcp",
+        "add",
+        "--scope",
+        scope,
+        "--env",
+        f"DEVCOUNCIL_PROJECT_ROOT={project_root}",
+        "devcouncil",
+        *_server_args(project_root),
+    ]

package/src/devcouncil/integrations/clients/grok.py

@@ -0,0 +1,105 @@
+"""Grok Build integration adapter."""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from devcouncil.integrations.clients import common as _common
+
+_project_root = _common._project_root
+_format_command = _common._format_command
+_run = _common._run
+_mutate_raw_config = _common._mutate_raw_config
+_configure = _common._configure
+
+console = _common.console
+
+
+def _grok_config_path(project_root: Path) -> Path:
+    return project_root / ".grok" / "config.toml"
+
+
+def _grok_mcp_toml_snippet(project_root: Path) -> str:
+    root = str(project_root)
+    return (
+        "[mcp_servers.devcouncil]\n"
+        'command = "devcouncil"\n'
+        'args = ["mcp-server"]\n'
+        f'env = {{ DEVCOUNCIL_PROJECT_ROOT = "{root}" }}\n'
+    )
+
+
+def _grok_mcp_command(project_root: Path) -> list[str]:
+    return [
+        "grok",
+        "mcp",
+        "add",
+        "devcouncil",
+        "--scope",
+        "project",
+        "-e",
+        f"DEVCOUNCIL_PROJECT_ROOT={project_root}",
+        "--",
+        "devcouncil",
+        "mcp-server",
+    ]
+
+
+def _merge_grok_config_toml(project_root: Path) -> Path:
+    path = _grok_config_path(project_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    snippet = _grok_mcp_toml_snippet(project_root)
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    if "mcp_servers.devcouncil" in existing or "[mcp_servers.devcouncil]" in existing:
+        return path
+    separator = "\n" if existing and not existing.endswith("\n") else ""
+    path.write_text(f"{existing}{separator}\n{snippet}", encoding="utf-8")
+    return path
+
+
+def _record_grok_config(project_root: Path) -> None:
+    def mutate(config: dict) -> None:
+        grok = config.setdefault("integrations", {}).setdefault("grok", {})
+        grok.update({
+            "enabled": True,
+            "config_path": str(_grok_config_path(project_root).relative_to(project_root)),
+        })
+
+    _mutate_raw_config(project_root, mutate)
+
+
+def _configure_grok(project_root: Path, apply: bool) -> bool:
+    path = _grok_config_path(project_root)
+    cli_command = _grok_mcp_command(project_root)
+    if not apply:
+        console.print("[bold]Grok Build[/bold]")
+        console.print(f"Preferred MCP registration: [dim]{_format_command(cli_command)}[/dim]")
+        console.print(f"Fallback project MCP config: [dim]{path}[/dim]")
+        console.print(_grok_mcp_toml_snippet(project_root), soft_wrap=True)
+        console.print(
+            "Project hooks require trust — run [dim]/hooks-trust[/dim] in Grok after install."
+        )
+        console.print("Verify with: [dim]grok mcp list --json[/dim]")
+        return True
+
+    if shutil.which("grok"):
+        code = _run(cli_command)
+        if code == 0:
+            _record_grok_config(project_root)
+            console.print("[green]Grok MCP server registered via grok mcp add.[/green]")
+            return True
+        console.print(
+            "[yellow]grok mcp add failed; falling back to .grok/config.toml merge.[/yellow]"
+        )
+
+    try:
+        written = _merge_grok_config_toml(project_root)
+    except OSError as exc:
+        console.print(f"[red]Failed to write Grok MCP config: {exc}[/red]")
+        return False
+    _record_grok_config(project_root)
+    console.print(f"[green]Grok MCP config written:[/green] {written}")
+    console.print(
+        "[dim]Trust project hooks with /hooks-trust (or grok --trust) before pre-action gates run.[/dim]"
+    )
+    return True