gemcode 0.3.39__tar.gz → 0.3.41__tar.gz

{gemcode-0.3.39/src/gemcode.egg-info → gemcode-0.3.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.39
+Version: 0.3.41
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.39 → gemcode-0.3.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.3.39"
+version = "0.3.41"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.3.39 → gemcode-0.3.41}/src/gemcode/agent.py

@@ -398,22 +398,27 @@ You run locally via the GemCode CLI. You are the same agent the user launched
 
 ## Core identity and approach
 
-### Classify before acting — choose the right mode for each message
+### Intent-aware workflow
 
-Not every message is a coding task. Read the intent first and pick the right mode:
+Before you see this message, a **gemini-2.5-flash-lite** intent classifier already determined the user's intent
+and stored it in session state as `_gemcode_intent`. Read it and adapt your behaviour:
 
-| Message type | Examples | Right action |
+| `_gemcode_intent` | Meaning | What to do |
 |---|---|---|
-| **Greeting / chitchat** | "hi", "hii", "hello", "how are you", "thanks" | Reply directly. No tools. No orientation. |
-| **Pure question / concept** | "what is a closure?", "explain OAuth", "which is better, Redis or Postgres?" | Answer from knowledge. No tools unless the answer requires inspecting *this* repo. |
-| **Vague project question** | "how does auth work here?", "what's the folder structure?" | Call 1–2 read-only tools to find the answer, then reply. Keep it focused. |
-| **Engineering task** | "add pagination", "fix the bug in auth.ts", "refactor the DB layer" | Full workflow: orient → plan → execute → verify. |
-| **Analysis / research** | "analyse the whole backend", "summarise all API endpoints" | Systematic tool use: list → read → grep → synthesise. |
+| `GREETING` | Social / chitchat | *(You will never see this — handled upstream before reaching you.)* |
+| `CONCEPT` | General knowledge question | Answer from your training knowledge. No tools unless the answer truly requires this repo's files. |
+| `PROJECT_QUESTION` | Question about this codebase | Use 1–2 focused read-only tools (`list_directory`, `read_file`, `grep_content`) to find the answer, then reply concisely. |
+| `ENGINEERING_TASK` | Code modification / fix / build | Full workflow: **Orient → Plan → Execute → Verify**. |
+| `ANALYSIS` | Systematic audit or summarisation | Thorough tool sweep: list → read → grep across the affected area, then synthesise findings. |
 
-**NEVER call `list_directory`, `read_project_notes`, or any tool in response to a greeting or a general conversational message.** If you wouldn't call a tool to answer "hi" in a conversation, don't call it here either.
+If `_gemcode_intent` is not set (first turn or classifier unavailable), infer the intent yourself
+from the message before acting — the categories above still apply.
+
+**Under no circumstances call `list_directory`, `read_project_notes`, or any tool in
+response to a greeting or a simple general question that requires no project context.**
 
 ### Engineering task workflow
-When the message is a real engineering task:
+When the intent is `ENGINEERING_TASK`:
 1. **Orient** — use `list_directory`, `glob_files`, `grep_content`, `read_file` to understand structure. These tools need **no permission** and are instant.
 2. **Plan** — for complex tasks, call `todo_write` upfront to map out the work.
 3. **Execute** — make the changes, run the checks, iterate.
@@ -442,8 +447,7 @@ You have native deep thinking capability — use it actively:
 - **For trade-off decisions** (which library, which pattern, which approach): reason through the pros/cons given this specific codebase.
 
 ## Interpreting requests
-- **Greetings / conversational messages** ("hi", "hii", "hey", "thanks", "cool"): reply naturally with one sentence. Do NOT call any tools. Do NOT apologise for not running code.
-- **General questions** that don't mention files or code ("what is X?", "explain Y"): answer from your knowledge directly. Only use tools if verifying something in *this specific repo* would materially improve the answer.
+- **Let `_gemcode_intent` guide you.** The pre-classifier already did the hard work. Trust it and act accordingly (see the table above).
 - **Engineering tasks** ("fix", "add", "refactor", "analyse", "debug"): infer from the repo — search, read, then act. Do not give abstract advice when concrete files exist.
 - If the user refers to symbols or behaviors, **find them** with `glob_files`/`grep_content`/`list_directory` — never ask them to paste paths you can discover yourself.
 - **Never propose edits to files you haven't read.** Read first, then edit.

{gemcode-0.3.39 → gemcode-0.3.41}/src/gemcode/cli.py

@@ -154,6 +154,17 @@ async def _run_prompt(
   # MCP and OpenAPI toolsets are now loaded inside create_runner() directly.
   runner = create_runner(cfg, extra_tools=None)
   try:
+    # LLM intent pre-classifier: greetings bypass the main agent entirely.
+    try:
+      from gemcode.intent_classifier import (
+          classify_intent, generate_greeting_reply, INTENT_GREETING
+      )
+      _intent = await classify_intent(prompt)
+      if _intent == INTENT_GREETING:
+        return await generate_greeting_reply(prompt)
+    except Exception:
+      pass
+
     collected = await run_turn(
         runner,
         user_id="local",

gemcode-0.3.41/src/gemcode/intent_classifier.py

@@ -0,0 +1,226 @@
+"""
+LLM-based intent pre-classifier.
+
+Before each user turn a lightweight Gemini call (gemini-2.5-flash-lite by
+default) classifies the message into one of five intents.  The TUI / CLI
+can then:
+
+  - Short-circuit GREETING turns entirely (instant reply, zero tool calls)
+  - Inject the intent label into session state so the main agent adapts its
+    workflow automatically without re-classifying
+
+Configure:
+  GEMCODE_INTENT_MODEL  Override the classifier model (default: gemini-2.5-flash-lite)
+  GEMCODE_INTENT_CLASSIFY_ENABLED  Set "0" to disable (falls back to main agent)
+"""
+from __future__ import annotations
+
+import os
+
+# ── Intent labels ─────────────────────────────────────────────────────────────
+INTENT_GREETING          = "GREETING"
+INTENT_CONCEPT           = "CONCEPT"
+INTENT_PROJECT_QUESTION  = "PROJECT_QUESTION"
+INTENT_ENGINEERING_TASK  = "ENGINEERING_TASK"
+INTENT_ANALYSIS          = "ANALYSIS"
+
+_VALID_INTENTS = {
+    INTENT_GREETING,
+    INTENT_CONCEPT,
+    INTENT_PROJECT_QUESTION,
+    INTENT_ENGINEERING_TASK,
+    INTENT_ANALYSIS,
+}
+
+# Mapping from intent to a short description injected into the main agent's context
+INTENT_DESCRIPTIONS: dict[str, str] = {
+    INTENT_GREETING:         "Conversational greeting or social message — reply warmly, no tools.",
+    INTENT_CONCEPT:          "General knowledge question — answer from knowledge, no project files needed.",
+    INTENT_PROJECT_QUESTION: "Question about this specific codebase — use 1-2 read-only tools, then reply.",
+    INTENT_ENGINEERING_TASK: "Code task (fix / add / refactor / debug) — orient → plan → execute → verify.",
+    INTENT_ANALYSIS:         "Systematic audit or summarisation — thorough tool sweep, then synthesise.",
+}
+
+# One-line summaries for the TUI — same visual lane as ∴ Thinking (collapsed)
+INTENT_THINKING_SUMMARY: dict[str, str] = {
+    INTENT_GREETING:         "Greeting / chitchat — no tools",
+    INTENT_CONCEPT:          "General knowledge — answer without repo reads if possible",
+    INTENT_PROJECT_QUESTION: "About this repo — a few read-only tools, then answer",
+    INTENT_ENGINEERING_TASK: "Engineering task — orient → plan → execute → verify",
+    INTENT_ANALYSIS:         "Deep analysis — systematic read / grep / synthesise",
+}
+
+# How the intent was determined (for TUI suffix)
+SOURCE_LOCAL = "local"   # obvious greeting / heuristic, no classifier API call
+SOURCE_LLM = "llm"       # gemini-2.5-flash-lite classifier
+SOURCE_OFF = "off"       # classifier disabled
+
+
+def format_intent_thinking_line(intent: str, source: str) -> str | None:
+    """
+    Single line of text after ``∴ Intent`` in the TUI (same visual lane as
+    collapsed ``∴ Thinking``).  Returns None when the classifier is off and
+    nothing should be shown.
+    """
+    if source == SOURCE_OFF:
+        return None
+    summary = INTENT_THINKING_SUMMARY.get(intent, intent)
+    if source == SOURCE_LOCAL:
+        tag = "instant"
+    else:
+        tag = "flash-lite classifier"
+    return f"{intent} — {summary}  ·  {tag}"
+
+# ── Prompts ───────────────────────────────────────────────────────────────────
+_CLASSIFY_PROMPT = """\
+Classify the user message into exactly ONE intent label from the list below.
+
+Labels:
+  GREETING          — greetings, thanks, social messages, chitchat
+                      (hi, hii, hello, hey, thanks, cool, nice, ok, goodbye, how are you, etc.)
+  CONCEPT           — general knowledge question needing no project files
+                      (what is X, explain Y, compare A vs B, best practice for Z)
+  PROJECT_QUESTION  — question about THIS specific codebase
+                      (how does auth work here, what does this file do, where is X defined)
+  ENGINEERING_TASK  — request to write, fix, modify, debug, or implement code
+  ANALYSIS          — request to systematically audit, review, summarise, or map the codebase
+
+User message: "{message}"
+
+Reply with ONLY the label name, nothing else."""
+
+_GREETING_SYSTEM = (
+    "You are GemCode, an expert coding assistant. "
+    "The user sent you a short conversational message. "
+    "Reply naturally and warmly in ONE brief sentence. "
+    "Do not mention code, tools, files, or ask what they need."
+)
+
+_CLASSIFIER_MODEL_ENV = "GEMCODE_INTENT_MODEL"
+_DEFAULT_CLASSIFIER_MODEL = "gemini-2.5-flash-lite"
+
+# Single-word / very-short messages that are unambiguously greetings —
+# checked locally before spending an API call on the classifier.
+_OBVIOUS_GREETINGS: frozenset[str] = frozenset({
+    "hi", "hii", "hiii", "hey", "hello", "heya", "hiya", "howdy", "sup", "yo",
+    "thanks", "thank you", "thx", "ty", "thankyou",
+    "cool", "nice", "great", "awesome", "ok", "okay", "k",
+    "bye", "goodbye", "cya", "later",
+    "good morning", "good evening", "good night", "good afternoon",
+    "what's up", "whats up", "wassup",
+})
+
+
+def _classifier_enabled() -> bool:
+    v = os.environ.get("GEMCODE_INTENT_CLASSIFY_ENABLED", "1")
+    return v.lower() not in ("0", "false", "no", "off")
+
+
+def _get_classifier_model() -> str:
+    return os.environ.get(_CLASSIFIER_MODEL_ENV) or _DEFAULT_CLASSIFIER_MODEL
+
+
+def _get_api_key() -> str:
+    return (
+        os.environ.get("GOOGLE_API_KEY")
+        or os.environ.get("GEMINI_API_KEY")
+        or ""
+    )
+
+
+async def classify_intent_with_source(message: str) -> tuple[str, str]:
+    """
+    Classify a user message; return (intent, source).
+
+    ``source`` is one of: ``SOURCE_LOCAL`` (heuristic, no API call),
+    ``SOURCE_LLM`` (classifier model), ``SOURCE_OFF`` (classifier disabled).
+    """
+    if not _classifier_enabled():
+        return INTENT_ENGINEERING_TASK, SOURCE_OFF
+
+    stripped = (message or "").strip()
+    if not stripped:
+        return INTENT_GREETING, SOURCE_LOCAL
+
+    # Fast local check for unambiguously short greetings — saves an API round-trip.
+    lower = stripped.lower()
+    if lower in _OBVIOUS_GREETINGS or (len(lower) <= 3 and lower.isalpha()):
+        return INTENT_GREETING, SOURCE_LOCAL
+
+    try:
+        import google.genai as genai
+        from google.genai import types as gtypes
+
+        client = genai.Client(api_key=_get_api_key())
+        resp = await client.aio.models.generate_content(
+            model=_get_classifier_model(),
+            contents=_CLASSIFY_PROMPT.format(message=stripped[:600]),
+            config=gtypes.GenerateContentConfig(
+                temperature=0.0,
+                max_output_tokens=15,
+            ),
+        )
+        label = (resp.text or "").strip().upper()
+        # Exact match first
+        if label in _VALID_INTENTS:
+            return label, SOURCE_LLM
+        # Partial match (model may return extra punctuation or lowercase)
+        for key in _VALID_INTENTS:
+            if key in label:
+                return key, SOURCE_LLM
+        return INTENT_ENGINEERING_TASK, SOURCE_LLM
+    except Exception:
+        return INTENT_ENGINEERING_TASK, SOURCE_LLM
+
+
+async def classify_intent(message: str) -> str:
+    """
+    Classify a user message using a lightweight Gemini call.
+
+    Returns one of: GREETING, CONCEPT, PROJECT_QUESTION, ENGINEERING_TASK, ANALYSIS.
+    Falls back to ENGINEERING_TASK on any error (the main agent handles all real
+    tasks safely with that default).
+
+    Classification is disabled when GEMCODE_INTENT_CLASSIFY_ENABLED=0.
+    """
+    intent, _ = await classify_intent_with_source(message)
+    return intent
+
+
+async def generate_greeting_reply(message: str) -> str:
+    """
+    Generate a warm, natural one-sentence reply for a greeting message.
+
+    Uses the same lightweight classifier model so the response is instant.
+    Falls back to a generic reply on any error.
+    """
+    try:
+        import google.genai as genai
+        from google.genai import types as gtypes
+
+        client = genai.Client(api_key=_get_api_key())
+        resp = await client.aio.models.generate_content(
+            model=_get_classifier_model(),
+            contents=[
+                gtypes.Content(
+                    role="user",
+                    parts=[gtypes.Part(text=_GREETING_SYSTEM)],
+                ),
+                gtypes.Content(
+                    role="model",
+                    parts=[gtypes.Part(text="Got it.")],
+                ),
+                gtypes.Content(
+                    role="user",
+                    parts=[gtypes.Part(text=message)],
+                ),
+            ],
+            config=gtypes.GenerateContentConfig(
+                temperature=0.8,
+                max_output_tokens=80,
+            ),
+        )
+        text = (resp.text or "").strip()
+        return text or "Hey! What can I help you with today?"
+    except Exception:
+        return "Hey! What can I help you with today?"

{gemcode-0.3.39 → gemcode-0.3.41}/src/gemcode/pricing.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 _PRICING_TABLE: dict[str, tuple[float, float]] = {
     # ── Gemini 2.5 ──────────────────────────────────────────────────────────
     "gemini-2.5-pro":         (3.50, 10.50),   # standard context ≤200k
+    "gemini-2.5-flash-lite":  (0.10,  0.40),   # lowest-cost 2.5 (must precede flash)
     "gemini-2.5-flash":       (0.15,  0.60),   # standard context
     "gemini-2.5-flash-8b":    (0.037, 0.15),   # 8B lite variant
     # ── Gemini 2.0 ──────────────────────────────────────────────────────────

{gemcode-0.3.39 → gemcode-0.3.41}/src/gemcode/tui/scrollback.py

@@ -515,6 +515,60 @@ async def run_gemcode_scrollback_tui(
         continue
       prompt = slash.model_prompt or prompt
 
+    # ── LLM intent pre-classifier ────────────────────────────────────────────
+    # gemini-2.5-flash-lite classifies the message (same lane as Thinking)
+    try:
+      from gemcode.intent_classifier import (
+          classify_intent_with_source,
+          generate_greeting_reply,
+          format_intent_thinking_line,
+          INTENT_GREETING,
+          INTENT_DESCRIPTIONS,
+      )
+      _intent, _intent_src = await classify_intent_with_source(prompt)
+      _intent_line = format_intent_thinking_line(_intent, _intent_src)
+      if _intent_line:
+        print(
+            f"  \u23bf  {ansi.dim}\u2234 Intent  {_intent_line}{ansi.reset}"
+        )
+        print("")
+
+      if _intent == INTENT_GREETING:
+        _start_anim("Replying\u2026")
+        try:
+          _reply = await generate_greeting_reply(prompt)
+        finally:
+          _stop_anim()
+        print(f"  \u23bf  {ansi.bold}GemCode{ansi.reset}:")
+        console.print(_RichPadding(_RichMarkdown(_reply), (0, 0, 0, 4)))
+        print("")
+        if os.environ.get("GEMCODE_TUI_TURN_RULE", "1").lower() in (
+            "1", "true", "yes", "on"
+        ):
+          print(f"{ansi.dim}{_hr(ch='─')}{ansi.reset}")
+        print("")
+        continue
+
+      # Non-greeting: store classified intent in session state so the main
+      # agent can read it and adapt its tool-use strategy accordingly.
+      try:
+        ss = runner.session_service
+        app = getattr(runner, "app_name", None) or getattr(cfg, "app_name", "gemcode")
+        sess = await ss.get_session(
+            app_name=app, user_id="local", session_id=current_session_id
+        )
+        if sess is not None:
+          _desc = INTENT_DESCRIPTIONS.get(_intent, _intent)
+          sess.state["_gemcode_intent"] = _intent
+          sess.state["_gemcode_intent_desc"] = _desc
+          await ss.update_session(sess)
+      except Exception:
+        pass  # State injection is best-effort
+
+    except Exception:
+      pass  # Classifier unavailable — fall through to main agent unchanged
+    # ─────────────────────────────────────────────────────────────────────────
+
     # Snapshot pre-turn capability state so we can detect routing-triggered changes.
     _pre_dr  = cfg.enable_deep_research
     _pre_emb = cfg.enable_embeddings

{gemcode-0.3.39 → gemcode-0.3.41/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.39
+Version: 0.3.41
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.39 → gemcode-0.3.41}/src/gemcode.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/gemcode/context_warning.py
 src/gemcode/credentials.py
 src/gemcode/hitl_session.py
 src/gemcode/hooks.py
+src/gemcode/intent_classifier.py
 src/gemcode/interactions.py
 src/gemcode/invoke.py
 src/gemcode/kairos_daemon.py