gdmcode 0.1.4__tar.gz → 0.1.6__tar.gz

{gdmcode-0.1.4 → gdmcode-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gdmcode
-Version: 0.1.4
+Version: 0.1.6
 Summary: gdm: AI coding agent for professional developers
 Project-URL: Homepage, https://github.com/guidegdm/gdmcode
 Project-URL: Repository, https://github.com/guidegdm/gdmcode

gdmcode-0.1.6/gdmcode/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.6"

{gdmcode-0.1.4 → gdmcode-0.1.6}/gdmcode/agent/tool_orchestrator.py

@@ -25,7 +25,7 @@ from typing import Any
 from gdmcode._internal.constants import _ALWAYS_DENY_TOOLS, _WRITE_TOOLS
 from gdmcode.exceptions import ToolPermissionError
 from gdmcode.security import AuditLogger
-from gdmcode.tools import REGISTRY, ToolResult
+from gdmcode.tools import REGISTRY, ToolResult, ensure_default_tools_registered
 
 __all__ = ["ToolOrchestrator"]
 
@@ -144,15 +144,7 @@ _TOOL_CACHE: _ToolResultCache = _ToolResultCache()
 
 def _ensure_tools_registered() -> None:
     """Import all tool modules so they register themselves with REGISTRY."""
-    import gdmcode.tools.bash_tool      # noqa: F401
-    import gdmcode.tools.read_tools     # noqa: F401
-    import gdmcode.tools.search_tools   # noqa: F401
-    import gdmcode.tools.shell_tools    # noqa: F401
-    import gdmcode.tools.ask_user_tool  # noqa: F401
-    import gdmcode.tools.write_tools    # noqa: F401
-    import gdmcode.tools.dep_tools      # noqa: F401
-    import gdmcode.tools.impact_tools   # noqa: F401
-    import gdmcode.tools.browser_tool   # noqa: F401
+    ensure_default_tools_registered()
 
 
 _ensure_tools_registered()
@@ -399,4 +391,4 @@ class ToolOrchestrator:
         """Dispatch a registered plugin tool by its namespaced tool_name."""
         if tool_name not in self._plugin_channels:
             raise KeyError(f"Unknown plugin tool: {tool_name}")
-        return self._dispatch_plugin(tool_name, args)
+        return self._dispatch_plugin(tool_name, args)

{gdmcode-0.1.4 → gdmcode-0.1.6}/gdmcode/cli.py

@@ -287,7 +287,8 @@ def cmd_health(
         GdmDatabase = _GdmDatabase
     from gdmcode.models.definitions import PROVIDER_BASE_URLS, ModelTier, get_model
     if REGISTRY is None:
-        from gdmcode.tools import REGISTRY as _REGISTRY
+        from gdmcode.tools import REGISTRY as _REGISTRY, ensure_default_tools_registered
+        ensure_default_tools_registered()
         REGISTRY = _REGISTRY
 
     @dataclass
@@ -347,13 +348,61 @@ def cmd_health(
         except Exception as exc:  # noqa: BLE001
             return CheckResult(f"api ({cfg.provider})", "fail", detail=str(exc)[:60])
 
+    def _check_completion() -> CheckResult:
+        t0 = time.monotonic()
+        try:
+            from gdmcode.models.client import GdmClient
+
+            model_def = get_model(ModelTier.CODER, cfg.provider)
+            proxy_active = bool(
+                getattr(cfg, "proxy_enabled", False)
+                and getattr(cfg, "proxy_url", "")
+                and getattr(cfg, "proxy_token", "")
+            )
+            client = (
+                GdmClient.for_proxy(getattr(cfg, "proxy_url"), getattr(cfg, "proxy_token"))
+                if proxy_active
+                else GdmClient(cfg)
+            )
+            text = client.complete_text(
+                "Reply with exactly: OK",
+                model=model_def.id,
+                max_tokens=8,
+                system="You are a health check. Reply only with OK.",
+            )
+            status = "ok" if text.strip() else "fail"
+            detail = f"{model_def.id}: {text.strip()[:30] or 'empty response'}"
+            return CheckResult("llm completion", status, latency_ms=int((time.monotonic() - t0) * 1000), detail=detail, priority="P0")
+        except Exception as exc:  # noqa: BLE001
+            return CheckResult("llm completion", "fail", latency_ms=int((time.monotonic() - t0) * 1000), detail=str(exc)[:120], priority="P0")
+
     def _check_tools() -> CheckResult:
         t0 = time.monotonic()
         try:
             tools = REGISTRY.all_tools()
             count = len(tools)
-            status = "ok" if count > 0 else "fail"
-            return CheckResult("tools", status, latency_ms=int((time.monotonic() - t0) * 1000), detail=f"{count} tools")
+            if count == 0:
+                return CheckResult("tools", "fail", latency_ms=int((time.monotonic() - t0) * 1000), detail="0 tools registered")
+            probe_name = "powershell" if sys.platform == "win32" else "bash"
+            probe_args = (
+                {"command": "$PWD.Path", "timeout": 5}
+                if probe_name == "powershell"
+                else {"command": "pwd", "timeout": 5, "read_only": True}
+            )
+            probe = REGISTRY.call(probe_name, probe_args)
+            if not probe.ok:
+                return CheckResult(
+                    "tools",
+                    "fail",
+                    latency_ms=int((time.monotonic() - t0) * 1000),
+                    detail=f"{count} registered; {probe_name} probe failed: {probe.error}",
+                )
+            return CheckResult(
+                "tools",
+                "ok",
+                latency_ms=int((time.monotonic() - t0) * 1000),
+                detail=f"{count} registered; {probe_name} probe ok",
+            )
         except Exception as exc:  # noqa: BLE001
             return CheckResult("tools", "fail", detail=str(exc))
 
@@ -380,10 +429,11 @@ def cmd_health(
         return results
 
     # Run scalar checks in parallel; sysdeps is fast so fine in its own slot
-    with ThreadPoolExecutor(max_workers=6) as executor:
+    with ThreadPoolExecutor(max_workers=7) as executor:
         f_db     = executor.submit(_check_db)
         f_daemon = executor.submit(_check_daemon)
         f_api    = executor.submit(_check_api)
+        f_completion = executor.submit(_check_completion)
         f_tools  = executor.submit(_check_tools)
         f_budget = executor.submit(_check_budget)
         f_sys    = executor.submit(_check_sysdeps)
@@ -392,13 +442,15 @@ def cmd_health(
         f_db.result(),
         f_daemon.result(),
         f_api.result(),
+        f_completion.result(),
         f_tools.result(),
         f_budget.result(),
         *f_sys.result(),
     ]
 
     overall_fail = any(
-        r.status in ("fail", "missing") and r.priority in ("P0", "P1")
+        r.status == "fail" and r.priority in ("P0", "P1")
+        or r.status == "missing" and r.priority == "P0"
         for r in all_checks
     )
 
@@ -1179,12 +1231,17 @@ def _run_one_shot(cfg: object, prompt: str, *, yes: bool, model_override: str |
     """
     from rich.status import Status
     from gdmcode.agent.loop import EventType
+    from gdmcode.repl import _format_llm_error, _is_connection_probe
 
     if not _has_model_connection(cfg):
         console.print("[red]No model connection configured.[/red]")
         console.print("Run [bold]gdm login grok[/bold], [bold]gdm login gemini[/bold], or start [bold]gdm[/bold] and use [bold]/proxy token[/bold] then [bold]/proxy on[/bold].")
         raise typer.Exit(1)
 
+    if _is_connection_probe(prompt):
+        _run_connection_probe_once(cfg, prompt, model_override=model_override)
+        return
+
     try:
         loop, cost_tracker, _db = _setup_agent(cfg, yes=yes, model_override=model_override)
     except Exception as exc:  # noqa: BLE001
@@ -1248,10 +1305,26 @@ def _run_one_shot(cfg: object, prompt: str, *, yes: bool, model_override: str |
                 console.print(event.content)
             elif event.type == EventType.ERROR:
                 status.stop()
-                console.print(f"[red]Error:[/red] {event.content}")
+                content = str(event.content or "")
+                if content.lower().startswith("max turns"):
+                    console.print(f"[yellow]Agent stopped before completion:[/yellow] {content}")
+                    console.print("[dim]Increase --max-turns or simplify the prompt.[/dim]")
+                else:
+                    console.print(_format_llm_error(event.content))
                 had_error = True
             elif event.type == EventType.TOOL_CALL:
+                status.stop()
                 console.print(f"[yellow]  [tool] {event.tool_name}[/yellow]")
+            elif event.type == EventType.TOOL_RESULT:
+                status.stop()
+                result = event.result
+                if result is not None and getattr(result, "error", None):
+                    console.print(f"[red]  [tool error] {event.tool_name}:[/red] {getattr(result, 'error')}")
+                    had_error = True
+                elif result is not None:
+                    output = (getattr(result, "output", "") or "").strip()
+                    if output:
+                        console.print(f"[dim]{output[:2000]}[/dim]")
             elif event.type == EventType.DONE:
                 status.stop()
     except Exception as exc:  # noqa: BLE001
@@ -1267,6 +1340,45 @@ def _run_one_shot(cfg: object, prompt: str, *, yes: bool, model_override: str |
         raise typer.Exit(1)
 
 
+def _run_connection_probe_once(cfg: object, prompt: str, *, model_override: str | None) -> None:
+    """Run a one-shot no-tools LLM connection probe."""
+    from rich.status import Status
+    from gdmcode.models.client import GdmClient
+    from gdmcode.models.definitions import ModelTier, get_model
+    from gdmcode.repl import _format_llm_error
+
+    status = Status("[cyan]Checking LLM connection...[/cyan]", console=console, spinner="dots")
+    status.start()
+    try:
+        tier = model_override or ModelTier.CODER
+        model_def = get_model(tier, cfg.provider)  # type: ignore[union-attr]
+        proxy_active = bool(
+            getattr(cfg, "proxy_enabled", False)
+            and getattr(cfg, "proxy_url", "")
+            and getattr(cfg, "proxy_token", "")
+        )
+        client = (
+            GdmClient.for_proxy(getattr(cfg, "proxy_url"), getattr(cfg, "proxy_token"))
+            if proxy_active
+            else GdmClient(cfg)  # type: ignore[arg-type]
+        )
+        response = client.complete_text(
+            prompt,
+            model=model_def.id,
+            max_tokens=80,
+            system=(
+                "You are gdm code's CLI connection check. Reply in one short, friendly "
+                "sentence. Confirm the LLM is connected. Do not inspect files or call tools."
+            ),
+        ).strip()
+        status.stop()
+        console.print(response or "[green]LLM connected.[/green]")
+    except Exception as exc:  # noqa: BLE001
+        status.stop()
+        console.print(_format_llm_error(exc))
+        raise typer.Exit(1) from exc
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------

{gdmcode-0.1.4 → gdmcode-0.1.6}/gdmcode/integrations/mcp_server.py

@@ -51,7 +51,7 @@ _INTERNAL_ERROR   = -32603
 class MCPServer:
     """Minimal MCP server with stdio transport."""
 
-    def __init__(self, name: str = "gdmcode", version: str = "0.1.4") -> None:
+    def __init__(self, name: str = "gdmcode", version: str = "0.1.6") -> None:
         self._name = name
         self._version = version
         self._tools: dict[str, MCPTool] = {}

{gdmcode-0.1.4 → gdmcode-0.1.6}/gdmcode/main.py

@@ -6,6 +6,7 @@ pyproject.toml's `gdm = "gdmcode.main:main"` script works.
 from __future__ import annotations
 
 from importlib.metadata import version as _pkg_version, PackageNotFoundError
+import sys
 
 from gdmcode.cli import app
 
@@ -20,8 +21,21 @@ def _get_version() -> str:
 
 def main() -> None:
     """Entry point for the `gdm` CLI command."""
+    _configure_stdio()
     app()
 
 
+def _configure_stdio() -> None:
+    """Avoid Windows cp1252 crashes when Rich output is redirected."""
+    for stream_name in ("stdout", "stderr"):
+        stream = getattr(sys, stream_name, None)
+        if stream is None or not hasattr(stream, "reconfigure"):
+            continue
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (OSError, ValueError):
+            pass
+
+
 if __name__ == "__main__":
     main()

{gdmcode-0.1.4 → gdmcode-0.1.6}/gdmcode/models/definitions.py

@@ -201,14 +201,14 @@ GEMINI_SCOUT = ModelDef(
 )
 
 GEMINI_CODER = ModelDef(
-    id="gemini-2.5-flash-8b",
+    id="gemini-2.5-flash",
     tier=ModelTier.CODER,
     provider=Provider.GEMINI,
     input_per_m=0.075,
     output_per_m=0.30,
     cached_per_m=0.0,
     context_window=1_000_000,
-    notes="Ultra-cheap bulk: file indexing, convention extraction, boilerplate edits.",
+    notes="Cheap bulk: file indexing, convention extraction, boilerplate edits.",
 )
 
 GEMINI_THINKER = ModelDef(
@@ -456,4 +456,3 @@ def get_capability(tier: str, provider: str, capability: str) -> bool:
         return bool(getattr(m, capability, False))
     except KeyError:
         return False
-

{gdmcode-0.1.4 → gdmcode-0.1.6}/gdmcode/repl.py

@@ -162,6 +162,35 @@ def _format_llm_error(error: object) -> str:
     return f"[red]{title}{code}.[/red]\n[dim]{escape(raw[:800])}[/dim]\n[yellow]{hint}[/yellow]"
 
 
+def _is_connection_probe(text: str) -> bool:
+    """Return True for tiny greetings/checks that should not enter tool mode."""
+    import re
+
+    normalized = re.sub(r"[^a-z0-9\s']", " ", text.lower()).strip()
+    normalized = re.sub(r"\s+", " ", normalized)
+    if not normalized:
+        return False
+    direct = {
+        "hey",
+        "hi",
+        "hello",
+        "yo",
+        "ping",
+        "test",
+        "hello there",
+        "hey there",
+        "hi there",
+        "are you there",
+        "you there",
+    }
+    if normalized in direct:
+        return True
+    words = normalized.split()
+    return len(words) <= 4 and words[0] in {"hey", "hi", "hello"} and all(
+        word in {"hey", "hi", "hello", "there", "gdm", "agent", "please"} for word in words
+    )
+
+
 def _render_event(event: object, status: Status, console: Console) -> bool:
     """Render one AgentEvent to the terminal while the spinner is live."""
     from gdmcode.agent.loop import EventType  # lazy
@@ -173,6 +202,7 @@ def _render_event(event: object, status: Status, console: Console) -> bool:
             label = f"[dim cyan]Thinking... {snippet}[/dim cyan]"
             status.update(label)
         case EventType.TOOL_CALL:
+            status.stop()
             console.print(f"[yellow][tool] {ev.tool_name}({_fmt_args(ev.args)})[/yellow]")  # type: ignore[union-attr]
         case EventType.TOOL_RESULT:
             result_str = str(ev.result or "")[:80]  # type: ignore[union-attr]
@@ -384,6 +414,51 @@ def start_repl(cfg: "GdmConfig", db: "GdmDatabase", *, yes: bool = False, model_
             console.print("[yellow]Agent loop not available in this installation.[/yellow]")
             return False
 
+    def _run_connection_probe(text: str) -> None:
+        """Send a tiny no-tools request to confirm the active LLM route."""
+        nonlocal cfg
+        if not _has_model_route():
+            try:
+                cfg = _reload_cfg(require_credentials=True)  # type: ignore[assignment]
+                dispatcher._cfg = cfg  # type: ignore[attr-defined]
+                dispatcher._provider = getattr(cfg, "provider", dispatcher._provider)  # type: ignore[attr-defined]
+            except Exception as exc:  # noqa: BLE001
+                _print_onboarding(console, error=str(exc))
+                return
+
+        status = Status("[cyan]Checking LLM connection...[/cyan]", console=console, spinner="dots")
+        status.start()
+        try:
+            from gdmcode.models.client import GdmClient
+            from gdmcode.models.definitions import ModelTier, get_model
+
+            tier = model_override or ModelTier.CODER
+            model_def = get_model(tier, cfg.provider)
+            proxy_active = bool(
+                getattr(cfg, "proxy_enabled", False)
+                and getattr(cfg, "proxy_url", "")
+                and getattr(cfg, "proxy_token", "")
+            )
+            client = (
+                GdmClient.for_proxy(getattr(cfg, "proxy_url"), getattr(cfg, "proxy_token"))
+                if proxy_active
+                else GdmClient(cfg)
+            )
+            response = client.complete_text(
+                text,
+                model=model_def.id,
+                max_tokens=80,
+                system=(
+                    "You are gdm code's CLI connection check. Reply in one short, friendly "
+                    "sentence. Confirm the LLM is connected. Do not inspect files or call tools."
+                ),
+            ).strip()
+            status.stop()
+            console.print(response or "[green]LLM connected.[/green]")
+        except Exception as exc:  # noqa: BLE001
+            status.stop()
+            console.print(_format_llm_error(exc))
+
     if not getattr(cfg, "gdm_quiet", False):
         if _has_model_route():
             console.print("[dim]Agent will initialize on first prompt.[/dim]")
@@ -587,6 +662,10 @@ def start_repl(cfg: "GdmConfig", db: "GdmDatabase", *, yes: bool = False, model_
                     console.print("[yellow]Restore not supported by current agent.[/yellow]")
             continue
 
+        if _is_connection_probe(text):
+            _run_connection_probe(text)
+            continue
+
         pending = _show_pending_btw(db, session_id, console)
         full_message = text
         if pending:

{gdmcode-0.1.4 → gdmcode-0.1.6}/gdmcode/tools/__init__.py

@@ -20,6 +20,7 @@ __all__ = [
     "ToolResult",
     "ToolRegistry",
     "REGISTRY",
+    "ensure_default_tools_registered",
     "BrowserTools",
     "BrowserToolResult",
 ]
@@ -155,6 +156,20 @@ class ToolRegistry:
 # Module-level singleton — all concrete tool modules import and extend this.
 REGISTRY: ToolRegistry = ToolRegistry()
 
+
+def ensure_default_tools_registered() -> None:
+    """Import built-in tool modules so they register with REGISTRY."""
+    import gdmcode.tools.bash_tool      # noqa: F401
+    import gdmcode.tools.read_tools     # noqa: F401
+    import gdmcode.tools.search_tools   # noqa: F401
+    import gdmcode.tools.shell_tools    # noqa: F401
+    import gdmcode.tools.ask_user_tool  # noqa: F401
+    import gdmcode.tools.write_tools    # noqa: F401
+    import gdmcode.tools.dep_tools      # noqa: F401
+    import gdmcode.tools.impact_tools   # noqa: F401
+    import gdmcode.tools.browser_tool   # noqa: F401
+
+
 # Re-export browser tools so callers can do `from gdmcode.tools import BrowserTools`.
 # Import after REGISTRY is defined to avoid circular imports.
 from gdmcode.tools.browser_tools import BrowserToolResult, BrowserTools, BrowserToolsSync  # noqa: E402, F401

{gdmcode-0.1.4 → gdmcode-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gdmcode"
-version = "0.1.4"
+version = "0.1.6"
 description = "gdm: AI coding agent for professional developers"
 readme = "README.md"
 license = { text = "MIT" }

gdmcode-0.1.6/tests/test_cli_smoke.py

@@ -0,0 +1,115 @@
+"""Smoke tests for gdm CLI entrypoints."""
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from gdmcode.cli import app
+
+runner = CliRunner()
+
+
+class TestCliSmoke:
+    def test_help_exits_zero(self) -> None:
+        result = runner.invoke(app, ["--help"])
+        assert result.exit_code == 0
+
+    def test_version_exits_zero(self) -> None:
+        result = runner.invoke(app, ["version"])
+        assert result.exit_code == 0
+
+    def test_doctor_exits_cleanly(self) -> None:
+        """doctor must exit 0 even if optional deps are missing."""
+        result = runner.invoke(app, ["doctor"])
+        assert result.exit_code == 0
+        assert "Core" in result.output
+
+    def test_doctor_shows_python_version(self) -> None:
+        result = runner.invoke(app, ["doctor"])
+        assert "Python" in result.output
+
+    def test_code_help_exits_zero(self) -> None:
+        result = runner.invoke(app, ["code", "--help"])
+        assert result.exit_code == 0
+
+    def test_login_help_exits_zero(self) -> None:
+        result = runner.invoke(app, ["login", "--help"])
+        assert result.exit_code == 0
+
+    def test_logout_help_exits_zero(self) -> None:
+        result = runner.invoke(app, ["logout", "--help"])
+        assert result.exit_code == 0
+
+    def test_daemon_help_exits_zero(self) -> None:
+        result = runner.invoke(app, ["daemon", "--help"])
+        assert result.exit_code == 0
+
+    def test_doctor_no_traceback_on_missing_deps(self) -> None:
+        """Graceful output even when optional packages absent."""
+        result = runner.invoke(app, ["doctor"])
+        assert "Traceback" not in result.output
+        assert "Traceback" not in (
+            result.exception.__class__.__name__ if result.exception else ""
+        )
+
+    def test_version_shows_version_string(self) -> None:
+        result = runner.invoke(app, ["version"])
+        assert "gdm" in result.output.lower() or "0." in result.output
+
+    def test_health_bootstraps_and_executes_tools(self, tmp_path, monkeypatch) -> None:
+        import gdmcode.cli as cli
+
+        class FakeDb:
+            def __init__(self, project_root):
+                self.project_root = project_root
+
+            def execute(self, *_args, **_kwargs):
+                return None
+
+        class FakeDaemon:
+            is_running = True
+
+            def __init__(self, db):
+                self.db = db
+
+            def pending_count(self):
+                return 0
+
+        monkeypatch.setattr(cli, "GdmDatabase", FakeDb)
+        monkeypatch.setattr(cli, "BackgroundDaemon", FakeDaemon)
+        monkeypatch.setattr(cli, "REGISTRY", None)
+        monkeypatch.setattr(
+            cli,
+            "load_config",
+            lambda: SimpleNamespace(provider="gemini", api_key="key", project_root=tmp_path),
+        )
+
+        response = SimpleNamespace(status_code=200)
+        with patch("gdmcode.cli.httpx.get", return_value=response):
+            with patch("gdmcode.models.client.GdmClient.complete_text", return_value="OK"):
+                result = runner.invoke(app, ["health"])
+
+        assert "tools" in result.output
+        assert "registered" in result.output
+        assert "probe ok" in result.output
+        assert "llm completion" in result.output
+
+    def test_one_shot_greeting_uses_connection_probe(self, tmp_path, monkeypatch) -> None:
+        import gdmcode.cli as cli
+
+        cfg = SimpleNamespace(provider="gemini", api_key="key", project_root=tmp_path)
+        monkeypatch.setattr(cli, "load_config", lambda require_credentials=False: cfg)
+        monkeypatch.setattr(cli, "_print_header", lambda _cfg: None)
+        monkeypatch.setattr(cli, "_has_model_connection", lambda _cfg: True)
+        probe = MagicMock()
+        monkeypatch.setattr(cli, "_run_connection_probe_once", probe)
+
+        result = runner.invoke(app, ["code", "--prompt", "hey"])
+
+        assert result.exit_code == 0
+        probe.assert_called_once()
+        assert probe.call_args.args[1] == "hey"
+        assert probe.call_args.kwargs == {"model_override": None}

{gdmcode-0.1.4 → gdmcode-0.1.6}/tests/test_health.py

@@ -22,6 +22,9 @@ def _make_cfg(**kwargs):
     cfg.provider = kwargs.get("provider", "grok")
     cfg.api_key = kwargs.get("api_key", "sk-test")
     cfg.project_root = Path("/tmp/gdm-test")
+    cfg.proxy_enabled = kwargs.get("proxy_enabled", False)
+    cfg.proxy_url = kwargs.get("proxy_url", "")
+    cfg.proxy_token = kwargs.get("proxy_token", None)
     return cfg
 
 
@@ -63,6 +66,7 @@ def _run_health(
     daemon = _make_daemon(running=daemon_running)
     mock_registry = MagicMock()
     mock_registry.all_tools.return_value = [MagicMock()] * tools_count
+    mock_registry.call.return_value = MagicMock(ok=True, output="ok", error=None)
 
     mock_response = MagicMock()
     mock_response.status_code = api_status
@@ -75,6 +79,7 @@ def _run_health(
         patch("gdmcode.cli.shutil.which", side_effect=lambda cmd: which_map.get(cmd)),
         patch("gdmcode.cli.httpx.get",
               side_effect=api_exc if api_exc else lambda *a, **kw: mock_response),
+        patch("gdmcode.models.client.GdmClient.complete_text", return_value="OK"),
     ):
         runner = CliRunner()
         result = runner.invoke(app, ["health", *args])
@@ -138,6 +143,7 @@ def test_api_probe_sends_auth_header():
     daemon = _make_daemon()
     mock_registry = MagicMock()
     mock_registry.all_tools.return_value = [MagicMock()]
+    mock_registry.call.return_value = MagicMock(ok=True, output="ok", error=None)
 
     with (
         patch("gdmcode.cli.load_config", return_value=cfg),
@@ -146,6 +152,7 @@ def test_api_probe_sends_auth_header():
         patch("gdmcode.cli.REGISTRY", mock_registry),
         patch("gdmcode.cli.shutil.which", return_value="/usr/bin/git"),
         patch("gdmcode.cli.httpx.get", side_effect=fake_get),
+        patch("gdmcode.models.client.GdmClient.complete_text", return_value="OK"),
     ):
         runner = CliRunner()
         runner.invoke(app, ["health"])
@@ -280,6 +287,7 @@ def test_parallel_execution_completes():
     daemon = _make_daemon()
     mock_registry = MagicMock()
     mock_registry.all_tools.return_value = [MagicMock()]
+    mock_registry.call.return_value = MagicMock(ok=True, output="ok", error=None)
 
     def slow_api(*a, **kw):
         import time as _t
@@ -295,6 +303,7 @@ def test_parallel_execution_completes():
         patch("gdmcode.cli.REGISTRY", mock_registry),
         patch("gdmcode.cli.shutil.which", return_value="/bin/git"),
         patch("gdmcode.cli.httpx.get", side_effect=slow_api),
+        patch("gdmcode.models.client.GdmClient.complete_text", return_value="OK"),
     ):
         runner = CliRunner()
         t0 = time.monotonic()

{gdmcode-0.1.4 → gdmcode-0.1.6}/tests/test_repl_smoke.py

@@ -39,6 +39,13 @@ class TestReplHelpers:
         from gdmcode.repl import _fmt_args
         assert _fmt_args({}) == ""
 
+    def test_connection_probe_detection(self) -> None:
+        from gdmcode.repl import _is_connection_probe
+
+        assert _is_connection_probe("hey")
+        assert _is_connection_probe("hello there")
+        assert not _is_connection_probe("fix the failing tests")
+
 
 class TestReplStartRepl:
     """Test start_repl runs and exits cleanly when given /exit input."""
@@ -157,6 +164,24 @@ class TestReplStartRepl:
         assert "/login grok" in output
         assert "/proxy token" in output
 
+    def test_plain_hey_with_credentials_uses_no_tool_probe(self, tmp_path, capsys) -> None:
+        from gdmcode.repl import start_repl
+
+        cfg, db = self._make_mocks(tmp_path)
+        cfg.api_key = "test-key"
+
+        with patch("gdmcode.repl._build_input_fn") as mock_build:
+            mock_build.return_value = MagicMock(side_effect=["hey", EOFError])
+            with patch("gdmcode.models.client.GdmClient.complete_text", return_value="Hey, LLM connected."):
+                with patch("gdmcode.repl._run_agent_turn") as run_agent:
+                    with patch("gdmcode.cost_tracker.CostTracker"):
+                        with patch("gdmcode.repl._ensure_session", return_value="session-123"):
+                            start_repl(cfg, db)
+
+        output = capsys.readouterr().out
+        assert "LLM connected" in output
+        run_agent.assert_not_called()
+
 
 class TestReplErrorFormatting:
     def test_format_llm_error_rate_limit(self) -> None:
@@ -193,6 +218,17 @@ class TestReplErrorFormatting:
         output = capsys.readouterr().out
         assert "credit" in output.lower() or "quota" in output.lower()
 
+    def test_render_tool_call_stops_spinner_before_permission_work(self, capsys) -> None:
+        from gdmcode.agent.loop import EventType
+        from gdmcode.repl import _render_event
+
+        status = MagicMock()
+        console = MagicMock()
+        event = SimpleNamespace(type=EventType.TOOL_CALL, tool_name="bash", args={"command": "ls -F"})
+
+        assert _render_event(event, status, console) is False
+        status.stop.assert_called_once()
+
 
 class TestCommandDispatcher:
     """Smoke tests for CommandDispatcher (called by start_repl)."""