gdmcode 0.1.8__tar.gz → 0.1.9__tar.gz

{gdmcode-0.1.8 → gdmcode-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gdmcode
-Version: 0.1.8
+Version: 0.1.9
 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.9/gdmcode/__init__.py

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

{gdmcode-0.1.8 → gdmcode-0.1.9}/gdmcode/cli.py

@@ -1231,14 +1231,15 @@ 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
+    from gdmcode.intent_router import PromptRoute, classify_prompt_route
+    from gdmcode.repl import _format_llm_error
 
     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):
+    if classify_prompt_route(prompt, cfg, model_override=model_override) == PromptRoute.LIGHTWEIGHT:
         _run_connection_probe_once(cfg, prompt, model_override=model_override)
         return
 

{gdmcode-0.1.8 → gdmcode-0.1.9}/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.8") -> None:
+    def __init__(self, name: str = "gdmcode", version: str = "0.1.9") -> None:
         self._name = name
         self._version = version
         self._tools: dict[str, MCPTool] = {}

gdmcode-0.1.9/gdmcode/intent_router.py

@@ -0,0 +1,223 @@
+"""Prompt intent routing for lightweight chat vs full agent mode."""
+from __future__ import annotations
+
+import logging
+import re
+from enum import Enum
+
+log = logging.getLogger(__name__)
+
+__all__ = [
+    "PromptRoute",
+    "classify_prompt_route",
+    "is_lightweight_prompt_heuristic",
+]
+
+
+class PromptRoute(str, Enum):
+    """Possible execution routes for a user prompt."""
+
+    LIGHTWEIGHT = "LIGHTWEIGHT"
+    AGENT = "AGENT"
+
+
+_WORK_TERMS: frozenset[str] = frozenset(
+    {
+        "fix",
+        "edit",
+        "change",
+        "create",
+        "write",
+        "delete",
+        "read",
+        "open",
+        "search",
+        "find",
+        "run",
+        "test",
+        "build",
+        "install",
+        "commit",
+        "review",
+        "debug",
+        "explain",
+        "refactor",
+        "implement",
+        "update",
+        "file",
+        "folder",
+        "repo",
+        "code",
+        "command",
+        "shell",
+        "terminal",
+        "powershell",
+        "bash",
+        "internet",
+        "web",
+        "download",
+    }
+)
+
+_LIGHTWEIGHT_EXACT: frozenset[str] = frozenset(
+    {
+        "hey",
+        "hi",
+        "hello",
+        "yo",
+        "ping",
+        "hello there",
+        "hey there",
+        "hi there",
+        "are you there",
+        "you there",
+        "who are you",
+        "what are you",
+        "what can you do",
+        "are you working",
+        "are you connected",
+        "is the llm connected",
+        "status",
+    }
+)
+
+_LIGHTWEIGHT_PREFIXES: tuple[str, ...] = (
+    "who are you",
+    "what are you",
+    "what can you do",
+    "are you there",
+    "are you connected",
+)
+
+_CLASSIFIER_SYSTEM = """Classify the user's prompt for a CLI coding agent.
+
+Reply with exactly one token:
+LIGHTWEIGHT - greetings, identity/capability questions, connection/status checks, or normal chat that does not need files, repo context, tools, internet, or commands.
+AGENT - anything that asks to inspect, read, search, edit, create, delete, run, test, build, install, debug, explain code/files/repo, use tools, access internet, or continue previous work.
+
+When uncertain, reply AGENT.
+"""
+
+
+def _normalize(text: str) -> str:
+    normalized = re.sub(r"[^a-z0-9\s']", " ", text.lower()).strip()
+    return re.sub(r"\s+", " ", normalized)
+
+
+def _looks_like_agent_work(text: str, normalized: str, words: list[str]) -> bool:
+    if any(word in _WORK_TERMS for word in words):
+        return True
+    if len(words) > 16:
+        return True
+    if "```" in text or "`" in text:
+        return True
+    if re.search(r"(?:^|\s)(?:\.?[/\\]|[a-zA-Z]:\\)", text):
+        return True
+    if re.search(r"\b[\w.-]+\.(?:py|js|ts|tsx|jsx|json|toml|yaml|yml|md|txt|go|rs|java|cs|cpp|c|h|html|css)\b", text, re.I):
+        return True
+    if normalized.startswith(("can you ", "please ", "could you ")) and any(word in _WORK_TERMS for word in normalized.split()):
+        return True
+    return False
+
+
+def is_lightweight_prompt_heuristic(text: str) -> bool:
+    """Return True only for prompts that are clearly lightweight without LLM help."""
+    normalized = _normalize(text)
+    if not normalized:
+        return False
+    words = normalized.split()
+    if _looks_like_agent_work(text, normalized, words):
+        return False
+    if normalized in _LIGHTWEIGHT_EXACT:
+        return True
+    if len(words) <= 8 and normalized.startswith(_LIGHTWEIGHT_PREFIXES):
+        return True
+    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 _has_model_route(cfg: object) -> bool:
+    return bool(
+        getattr(cfg, "api_key", "")
+        or (
+            getattr(cfg, "proxy_enabled", False)
+            and getattr(cfg, "proxy_url", "")
+            and getattr(cfg, "proxy_token", "")
+        )
+    )
+
+
+def _classifier_client(cfg: object):
+    from gdmcode.models.client import GdmClient
+
+    proxy_active = bool(
+        getattr(cfg, "proxy_enabled", False)
+        and getattr(cfg, "proxy_url", "")
+        and getattr(cfg, "proxy_token", "")
+    )
+    return (
+        GdmClient.for_proxy(getattr(cfg, "proxy_url"), getattr(cfg, "proxy_token"))
+        if proxy_active
+        else GdmClient(cfg)  # type: ignore[arg-type]
+    )
+
+
+def _parse_route(raw: str) -> PromptRoute:
+    return PromptRoute.LIGHTWEIGHT if raw.strip().upper() == PromptRoute.LIGHTWEIGHT else PromptRoute.AGENT
+
+
+def classify_prompt_route(
+    prompt: str,
+    cfg: object,
+    *,
+    model_override: str | None = None,
+    allow_llm: bool = True,
+) -> PromptRoute:
+    """Classify a prompt into lightweight chat or full agent mode.
+
+    The router is intentionally conservative: obvious work never calls the
+    classifier, unparseable classifier output becomes AGENT, and classifier
+    failures fall back only to the strict allow-list heuristic.
+    """
+    normalized = _normalize(prompt)
+    if not normalized:
+        return PromptRoute.AGENT
+
+    words = normalized.split()
+    if _looks_like_agent_work(prompt, normalized, words):
+        log.debug("prompt_route route=AGENT source=heuristic_work prompt=%r", prompt[:80])
+        return PromptRoute.AGENT
+
+    if is_lightweight_prompt_heuristic(prompt):
+        log.debug("prompt_route route=LIGHTWEIGHT source=heuristic_light prompt=%r", prompt[:80])
+        return PromptRoute.LIGHTWEIGHT
+
+    if not allow_llm or not _has_model_route(cfg):
+        route = PromptRoute.LIGHTWEIGHT if is_lightweight_prompt_heuristic(prompt) else PromptRoute.AGENT
+        log.debug("prompt_route route=%s source=fallback_no_llm prompt=%r", route.value, prompt[:80])
+        return route
+
+    try:
+        from gdmcode.models.definitions import ModelTier, get_model
+
+        tier = model_override or ModelTier.SCOUT
+        model_def = get_model(tier, getattr(cfg, "provider"))
+        raw = _classifier_client(cfg).complete_text(
+            prompt,
+            model=model_def.id,
+            max_tokens=4,
+            system=_CLASSIFIER_SYSTEM,
+        )
+        route = _parse_route(raw)
+        log.debug(
+            "prompt_route route=%s source=llm raw=%r prompt=%r",
+            route.value,
+            raw[:80],
+            prompt[:80],
+        )
+        return route
+    except Exception as exc:  # noqa: BLE001
+        fallback = PromptRoute.LIGHTWEIGHT if is_lightweight_prompt_heuristic(prompt) else PromptRoute.AGENT
+        log.warning("Prompt intent classifier failed; using %s fallback: %s", fallback.value, exc)
+        return fallback

{gdmcode-0.1.8 → gdmcode-0.1.9}/gdmcode/repl.py

@@ -163,59 +163,10 @@ def _format_llm_error(error: object) -> str:
 
 
 def _is_connection_probe(text: str) -> bool:
-    """Return True for lightweight chat/status prompts 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
-    work_terms = {
-        "fix", "edit", "change", "create", "write", "delete", "read", "open", "search",
-        "find", "run", "test", "build", "install", "commit", "review", "debug", "explain",
-        "refactor", "implement", "update", "file", "folder", "repo", "code",
-    }
-    words = normalized.split()
-    if any(word in work_terms for word in words):
-        return False
-    direct = {
-        "hey",
-        "hi",
-        "hello",
-        "yo",
-        "ping",
-        "test",
-        "hello there",
-        "hey there",
-        "hi there",
-        "are you there",
-        "you there",
-        "who are you",
-        "what are you",
-        "what can you do",
-        "are you working",
-        "are you connected",
-        "is the llm connected",
-        "are tools working",
-        "do tools work",
-        "status",
-    }
-    if normalized in direct:
-        return True
-    prefixes = (
-        "who are you",
-        "what are you",
-        "what can you do",
-        "are you there",
-        "are you connected",
-        "are tools working",
-        "do tools work",
-    )
-    if len(words) <= 8 and normalized.startswith(prefixes):
-        return True
-    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
-    )
+    """Compatibility wrapper for tests and older imports."""
+    from gdmcode.intent_router import is_lightweight_prompt_heuristic
+
+    return is_lightweight_prompt_heuristic(text)
 
 
 def _render_event(event: object, status: Status, console: Console) -> bool:
@@ -690,9 +641,12 @@ 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
+        if loop is None:
+            from gdmcode.intent_router import PromptRoute, classify_prompt_route
+
+            if classify_prompt_route(text, cfg, model_override=model_override) == PromptRoute.LIGHTWEIGHT:
+                _run_connection_probe(text)
+                continue
 
         pending = _show_pending_btw(db, session_id, console)
         full_message = text

{gdmcode-0.1.8 → gdmcode-0.1.9}/pyproject.toml

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

{gdmcode-0.1.8 → gdmcode-0.1.9}/tests/test_cli_smoke.py

@@ -132,3 +132,25 @@ class TestCliSmoke:
         assert result.exit_code == 0
         probe.assert_called_once()
         assert probe.call_args.args[1] == "who are you?"
+
+    def test_one_shot_ambiguous_prompt_uses_llm_router(self, tmp_path, monkeypatch) -> None:
+        import gdmcode.cli as cli
+        import gdmcode.intent_router as intent_router
+
+        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)
+        monkeypatch.setattr(
+            intent_router,
+            "classify_prompt_route",
+            lambda *_args, **_kwargs: intent_router.PromptRoute.LIGHTWEIGHT,
+        )
+        probe = MagicMock()
+        monkeypatch.setattr(cli, "_run_connection_probe_once", probe)
+
+        result = runner.invoke(app, ["code", "--prompt", "what's your name?"])
+
+        assert result.exit_code == 0
+        probe.assert_called_once()
+        assert probe.call_args.args[1] == "what's your name?"

gdmcode-0.1.9/tests/test_intent_router.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import patch
+
+
+def _cfg() -> SimpleNamespace:
+    return SimpleNamespace(
+        provider="gemini",
+        api_key="key",
+        proxy_enabled=False,
+        proxy_url="",
+        proxy_token="",
+    )
+
+
+def test_obvious_work_routes_to_agent_without_llm() -> None:
+    from gdmcode.intent_router import PromptRoute, classify_prompt_route
+
+    with patch("gdmcode.models.client.GdmClient.complete_text") as complete_text:
+        route = classify_prompt_route("can you inspect the repo and run tests?", _cfg())
+
+    assert route == PromptRoute.AGENT
+    complete_text.assert_not_called()
+
+
+def test_ambiguous_prompt_can_be_classified_lightweight_by_llm() -> None:
+    from gdmcode.intent_router import PromptRoute, classify_prompt_route
+
+    with patch("gdmcode.models.client.GdmClient.complete_text", return_value="LIGHTWEIGHT"):
+        route = classify_prompt_route("what's your name?", _cfg())
+
+    assert route == PromptRoute.LIGHTWEIGHT
+
+
+def test_unparseable_classifier_output_defaults_to_agent() -> None:
+    from gdmcode.intent_router import PromptRoute, classify_prompt_route
+
+    with patch("gdmcode.models.client.GdmClient.complete_text", return_value="This seems lightweight."):
+        route = classify_prompt_route("what's your name?", _cfg())
+
+    assert route == PromptRoute.AGENT
+
+
+def test_classifier_error_falls_back_conservatively() -> None:
+    from gdmcode.intent_router import PromptRoute, classify_prompt_route
+
+    with patch("gdmcode.models.client.GdmClient.complete_text", side_effect=RuntimeError("boom")):
+        route = classify_prompt_route("what's your name?", _cfg())
+
+    assert route == PromptRoute.AGENT

{gdmcode-0.1.8 → gdmcode-0.1.9}/tests/test_repl_smoke.py

@@ -46,7 +46,7 @@ class TestReplHelpers:
         assert _is_connection_probe("hello there")
         assert _is_connection_probe("who are you?")
         assert _is_connection_probe("what can you do?")
-        assert _is_connection_probe("are tools working?")
+        assert not _is_connection_probe("are tools working?")
         assert not _is_connection_probe("fix the failing tests")
         assert not _is_connection_probe("explain this file")
 
@@ -204,6 +204,27 @@ class TestReplStartRepl:
         assert "coding-agent CLI" in output
         run_agent.assert_not_called()
 
+    def test_ambiguous_lightweight_prompt_uses_llm_router(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=["what's your name?", EOFError])
+            with patch(
+                "gdmcode.models.client.GdmClient.complete_text",
+                side_effect=["LIGHTWEIGHT", "I am gdm, your coding-agent CLI."],
+            ):
+                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 "coding-agent CLI" in output
+        run_agent.assert_not_called()
+
 
 class TestReplErrorFormatting:
     def test_format_llm_error_rate_limit(self) -> None:

gdmcode-0.1.8/gdmcode/__init__.py

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