gdmcode 0.1.8__tar.gz → 0.1.10__tar.gz

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

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

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

{gdmcode-0.1.8 → gdmcode-0.1.10}/gdmcode/agent/loop.py

@@ -50,33 +50,33 @@ try:
     _analytics: "_UsageAnalytics | None" = _UsageAnalytics()
 except Exception:  # noqa: BLE001
     _analytics = None
-
-try:
-    from gdmcode.agent.risk_scorer import score_patch, RiskTier
-    _risk_scorer_available = True
-except Exception:  # noqa: BLE001
-    _risk_scorer_available = False
-
-
-def _check_patch_risk(diff, file_paths=None, autonomy_level=2):
-    """Score a patch diff and enforce risk gates based on autonomy level.
-
-    - CRITICAL (score >= block_threshold) and autonomy_level < 4: raises RuntimeError.
-    - HIGH tier and autonomy_level < 3: logs a warning (non-blocking).
-    - Always returns the PatchRiskResult (or None if scorer unavailable).
-    """
-    if not _risk_scorer_available:
-        return None
-    result = score_patch(diff, file_paths)
-    log.info("patch_risk score=%.3f tier=%s blocked=%s", result.score, result.tier, result.blocked)
-    if result.triggered_signals:
-        log.debug("patch_risk rationale:\n%s", result.rationale)
-    if result.blocked and autonomy_level < 4:
-        raise RuntimeError(f"Patch blocked: {result.rationale}")
-    if result.tier == RiskTier.HIGH and autonomy_level < 3:
-        log.warning("High-risk patch detected (score=%.3f). Review before applying:\n%s",
-                    result.score, result.rationale)
-    return result
+
+try:
+    from gdmcode.agent.risk_scorer import score_patch, RiskTier
+    _risk_scorer_available = True
+except Exception:  # noqa: BLE001
+    _risk_scorer_available = False
+
+
+def _check_patch_risk(diff, file_paths=None, autonomy_level=2):
+    """Score a patch diff and enforce risk gates based on autonomy level.
+
+    - CRITICAL (score >= block_threshold) and autonomy_level < 4: raises RuntimeError.
+    - HIGH tier and autonomy_level < 3: logs a warning (non-blocking).
+    - Always returns the PatchRiskResult (or None if scorer unavailable).
+    """
+    if not _risk_scorer_available:
+        return None
+    result = score_patch(diff, file_paths)
+    log.info("patch_risk score=%.3f tier=%s blocked=%s", result.score, result.tier, result.blocked)
+    if result.triggered_signals:
+        log.debug("patch_risk rationale:\n%s", result.rationale)
+    if result.blocked and autonomy_level < 4:
+        raise RuntimeError(f"Patch blocked: {result.rationale}")
+    if result.tier == RiskTier.HIGH and autonomy_level < 3:
+        log.warning("High-risk patch detected (score=%.3f). Review before applying:\n%s",
+                    result.score, result.rationale)
+    return result
 
 def _record_usage(
     session_id: str,
@@ -505,6 +505,11 @@ class AgentLoop:
             self._model = get_model(tier, self._cfg.provider)
             self._model_id = self._model.id
             self._gdm_client = self._make_client()
+            yield AgentEvent(
+                EventType.THINKING,
+                content=f"Using {self._model_id} for this turn.",
+                turn=0,
+            )
             log.debug(
                 "ModelRouter selected tier=%s mode=%s for prompt=%r",
                 tier,
@@ -587,6 +592,14 @@ class AgentLoop:
                     log.warning("BTW queue drain failed: %s", _btw_exc)
 
             tools = self._build_tool_specs()
+            yield AgentEvent(
+                EventType.THINKING,
+                content=(
+                    "Asking the model to choose the next step"
+                    + (f" with {len(tools)} available tools." if tools else ".")
+                ),
+                turn=turn_num,
+            )
             try:
                 response = self._gdm_client.complete(
                     self._transcript.to_messages(),
@@ -686,6 +699,13 @@ class AgentLoop:
 
             # Execute tool calls
             if raw_tool_calls:
+                tool_names = ", ".join(str(tc.get("function", {}).get("name", "tool")) for tc in raw_tool_calls[:3])
+                extra = "" if len(raw_tool_calls) <= 3 else f" (+{len(raw_tool_calls) - 3} more)"
+                yield AgentEvent(
+                    EventType.THINKING,
+                    content=f"Model selected tool step: {tool_names}{extra}.",
+                    turn=turn_num,
+                )
                 # Guard: finish_reason=tool_calls with empty list → infinite loop
                 if not msg.tool_calls:
                     yield AgentEvent(EventType.ERROR, turn=turn_num,
@@ -694,6 +714,11 @@ class AgentLoop:
                     return
 
                 yield from self._execute_tool_calls(msg.tool_calls, turn_num)
+                yield AgentEvent(
+                    EventType.THINKING,
+                    content="Feeding tool results back to the model.",
+                    turn=turn_num,
+                )
                 continue  # loop back to model with tool results
 
             # Natural completion
@@ -1407,4 +1432,3 @@ def write_autonomy_audit(
         (session_id, time.time(), level, action, json.dumps(details), checkpoint_id),
     )
     db_conn.commit()
-

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

@@ -29,6 +29,7 @@ import shutil
 import httpx
 import typer
 from rich.console import Console
+from rich.markup import escape
 
 from gdmcode import __version__
 from gdmcode.config import load_config
@@ -1231,14 +1232,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
 
@@ -1300,7 +1302,14 @@ def _run_one_shot(cfg: object, prompt: str, *, yes: bool, model_override: str |
     had_error = False
     try:
         for event in loop.run(prompt):  # type: ignore[union-attr]
-            if event.type == EventType.RESPONSE:
+            if event.type == EventType.THINKING:
+                status.stop()
+                snippet = str(event.content or "")[:120]
+                if snippet:
+                    console.print(f"[dim cyan]… {snippet}[/dim cyan]")
+                status.start()
+                status.update("[cyan]Working...[/cyan]")
+            elif event.type == EventType.RESPONSE:
                 status.stop()
                 console.print(event.content)
             elif event.type == EventType.ERROR:

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

gdmcode-0.1.10/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.10}/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:
@@ -226,8 +177,11 @@ def _render_event(event: object, status: Status, console: Console) -> bool:
     match ev.type:  # type: ignore[union-attr]
         case EventType.THINKING:
             snippet = str(ev.content or "")[:100]  # type: ignore[union-attr]
-            label = f"[dim cyan]Thinking... {snippet}[/dim cyan]"
-            status.update(label)
+            status.stop()
+            if snippet:
+                console.print(f"[dim cyan]… {escape(snippet)}[/dim cyan]")
+            status.start()
+            status.update("[cyan]Working...[/cyan]")
         case EventType.TOOL_CALL:
             status.stop()
             console.print(f"[yellow][tool] {ev.tool_name}({_fmt_args(ev.args)})[/yellow]")  # type: ignore[union-attr]
@@ -690,9 +644,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.10}/pyproject.toml

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

{gdmcode-0.1.8 → gdmcode-0.1.10}/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.10/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.10}/tests/test_loop.py

@@ -268,6 +268,10 @@ class TestAgentLoop:
 
         mock_orchestrator.execute.assert_called_once_with("bash", {"command": "ls"}, model_id=loop._model.id)
         event_types = [e.type for e in events]
+        thinking = [e.content for e in events if e.type == EventType.THINKING]
+        assert any("Asking the model" in content for content in thinking)
+        assert any("Model selected tool step: bash" in content for content in thinking)
+        assert any("Feeding tool results back" in content for content in thinking)
         assert EventType.TOOL_CALL in event_types
         assert EventType.TOOL_RESULT in event_types
         assert EventType.DONE in event_types

{gdmcode-0.1.8 → gdmcode-0.1.10}/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"