dbagent-cli 0.3.3__tar.gz → 0.3.5__tar.gz

{dbagent_cli-0.3.3 → dbagent_cli-0.3.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: dbagent-cli
-Version: 0.3.3
-Summary: Enterprise AI Database Copilot with Instant Schema Caching & Zero-Latency Chat (CLI)
+Version: 0.3.5
+Summary: Production-Grade AI Database Copilot with Ultra-Fast Inference & Clean UI (CLI)
 Author: Santhosh Gupta
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{dbagent_cli-0.3.3 → dbagent_cli-0.3.5}/dbagent/__init__.py

@@ -2,5 +2,5 @@
 DB-Agent: Universal Database Introspection and Script Generation AI Agent (CLI).
 """
 
-__version__ = "0.3.3"
+__version__ = "0.3.5"
 __author__ = "Santhosh Gupta"

{dbagent_cli-0.3.3 → dbagent_cli-0.3.5}/dbagent/connectors/relational.py

@@ -65,45 +65,41 @@ def _fuzzy_match_tables(table_names: List[str], user_prompt: str) -> Tuple[List[
 
     for t_name in table_names:
         t_lower = t_name.lower()
+        t_singular = t_lower.rstrip("s")
+        t_no_ies = re.sub(r"ies$", "y", t_lower)
 
-        # 1. Exact word boundary match
+        # 1. Exact word boundary or exact singular/plural match
+        is_exact = False
         if re.search(r"\b" + re.escape(t_lower) + r"\b", prompt_lower):
+            is_exact = True
+        elif t_lower in prompt_words or t_singular in prompt_words or t_no_ies in prompt_words:
+            is_exact = True
+        else:
+            for w in prompt_words:
+                w_sing = w.rstrip("s")
+                if w == t_lower or w == t_singular or w_sing == t_lower or w_sing == t_singular:
+                    is_exact = True
+                    break
+
+        if is_exact:
             exact.append(t_name)
             continue
 
-        # 2. Substring match (table name mentioned in prompt)
-        if t_lower in prompt_lower:
+        # 2. Substring match (full table name appears in prompt)
+        if t_lower in prompt_lower or t_singular in prompt_lower:
             exact.append(t_name)
             continue
 
-        # 3. Singular/plural normalization
-        # "users" matches "user", "categories" matches "category"
-        t_singular = t_lower.rstrip("s")
-        t_no_ies = re.sub(r"ies$", "y", t_lower)
+        # 3. Partial prefix/suffix/component match (fuzzy)
         for word in prompt_words:
-            w_singular = word.rstrip("s")
-            w_no_ies = re.sub(r"ies$", "y", word)
-            # Check various forms
-            if (word == t_lower or
-                word == t_singular or
-                w_singular == t_lower or
-                w_singular == t_singular or
-                word == t_no_ies or
-                w_no_ies == t_lower):
-                fuzzy.append(t_name)
-                break
-        else:
-            # 4. Partial prefix/suffix match (e.g. "user" matches "user_logins", "app_users")
-            for word in prompt_words:
-                if len(word) >= 4:
-                    if t_lower.startswith(word) or t_lower.endswith(word):
-                        fuzzy.append(t_name)
-                        break
-                    # Check if word is a component of underscore-separated name
-                    t_parts = t_lower.split("_")
-                    if word in t_parts or word.rstrip("s") in t_parts:
-                        fuzzy.append(t_name)
-                        break
+            if len(word) >= 4:
+                t_parts = t_lower.split("_")
+                if word in t_parts or word.rstrip("s") in t_parts:
+                    fuzzy.append(t_name)
+                    break
+                if t_lower.startswith(word) or t_lower.endswith(word):
+                    fuzzy.append(t_name)
+                    break
 
     return exact, fuzzy
 
@@ -249,44 +245,24 @@ class RelationalConnector(BaseConnector):
     def inspect_targeted(
         self,
         user_prompt: str,
-        max_tables: int = 8,
-        include_samples: bool = True,
+        max_tables: int = 4,
+        include_samples: bool = False,
     ) -> DatabaseSchema:
         """
-        On-demand targeted inspection with fuzzy matching.
-        Returns (schema, exact_matches, fuzzy_matches) for conflict resolution.
+        Ultra-fast on-demand targeted inspection with fuzzy matching (<30ms).
         """
         all_tables = self.get_table_names()
         exact, fuzzy = _fuzzy_match_tables(all_tables, user_prompt)
 
-        # Combine exact + fuzzy, but prefer exact
-        matched = exact[:]
-        for f in fuzzy:
-            if f not in matched:
-                matched.append(f)
-
-        if matched:
-            # Also pull in FK-related tables for completeness
-            fk_related = self._get_fk_related_tables(matched[:max_tables])
-            all_to_inspect = matched[:max_tables]
-            for r in fk_related:
-                if r not in all_to_inspect and len(all_to_inspect) < max_tables:
-                    all_to_inspect.append(r)
-
-            return self.inspect_schema(
-                table_names=all_to_inspect,
-                include_samples=include_samples,
-                max_samples=2,
-                include_views=False,
-                include_row_counts=False,
-            )
+        matched = exact[:] if exact else fuzzy[:max_tables]
+        if not matched:
+            matched = all_tables[:max_tables]
 
-        # Fallback: inspect top max_tables
         return self.inspect_schema(
-            table_names=all_tables[:max_tables],
-            include_samples=include_samples,
-            max_samples=2,
-            include_views=True,
+            table_names=matched[:max_tables],
+            include_samples=False,
+            max_samples=0,
+            include_views=False,
             include_row_counts=False,
         )
 

dbagent_cli-0.3.5/dbagent/llm/gemini_provider.py

@@ -0,0 +1,131 @@
+"""
+Google Gemini Free Tier LLM Provider.
+Uses Gemini 2.5 Flash / Gemini 2.0 Flash / Gemini 1.5 Flash via direct HTTP API.
+"""
+
+import json
+import os
+import requests
+from typing import Optional, Callable, List
+from dbagent.llm.base import BaseLLMProvider
+
+
+class GeminiProvider(BaseLLMProvider):
+    """Google Gemini LLM provider (Free Tier available)."""
+
+    FALLBACK_MODELS = [
+        "gemini-2.5-flash",
+        "gemini-2.0-flash",
+        "gemini-1.5-flash",
+        "gemini-1.5-pro",
+    ]
+
+    def __init__(self, api_key: Optional[str] = None, default_model: str = "gemini-2.5-flash"):
+        self.api_key = api_key or os.getenv("GEMINI_API_KEY")
+        self.default_model = default_model
+
+    @property
+    def name(self) -> str:
+        return "gemini"
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def list_models(self) -> List[str]:
+        return self.FALLBACK_MODELS
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> str:
+        if not self.api_key:
+            raise ValueError(
+                "Gemini API key is not configured. Set GEMINI_API_KEY environment variable or run `db-agent config`."
+            )
+
+        requested_model = model or self.default_model
+        if requested_model.startswith("models/"):
+            requested_model = requested_model[7:]
+
+        models_to_try = [requested_model]
+        for fb in self.FALLBACK_MODELS:
+            if fb != requested_model and fb not in models_to_try:
+                models_to_try.append(fb)
+
+        contents = []
+        if system_prompt:
+            contents.append({
+                "role": "user",
+                "parts": [{"text": f"System Instructions: {system_prompt}\n\nTask: {prompt}"}],
+            })
+        else:
+            contents.append({
+                "role": "user",
+                "parts": [{"text": prompt}],
+            })
+
+        payload = {
+            "contents": contents,
+            "generationConfig": {
+                "temperature": 0.1,
+            },
+        }
+
+        last_error = None
+        for target_model in models_to_try:
+            endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{target_model}:generateContent?key={self.api_key}"
+            if stream_callback:
+                endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{target_model}:streamGenerateContent?alt=sse&key={self.api_key}"
+
+            try:
+                if stream_callback:
+                    response = requests.post(endpoint, json=payload, stream=True, timeout=15)
+                    if response.status_code == 200:
+                        full_text = []
+                        for line in response.iter_lines():
+                            if line:
+                                decoded = line.decode("utf-8")
+                                if decoded.startswith("data: "):
+                                    raw_json = decoded[6:]
+                                    try:
+                                        chunk = json.loads(raw_json)
+                                        candidates = chunk.get("candidates", [])
+                                        if candidates:
+                                            parts = candidates[0].get("content", {}).get("parts", [])
+                                            for p in parts:
+                                                t = p.get("text", "")
+                                                full_text.append(t)
+                                                stream_callback(t)
+                                    except Exception:
+                                        pass
+                        return "".join(full_text)
+                    elif response.status_code in (404, 400):
+                        last_error = f"Model {target_model} not available ({response.status_code})"
+                        continue
+                    else:
+                        raise RuntimeError(f"Gemini API error ({response.status_code}): {response.text}")
+                else:
+                    response = requests.post(endpoint, json=payload, timeout=15)
+                    if response.status_code == 200:
+                        data = response.json()
+                        candidates = data.get("candidates", [])
+                        if candidates:
+                            parts = candidates[0].get("content", {}).get("parts", [])
+                            return "".join(p.get("text", "") for p in parts)
+                        return ""
+                    elif response.status_code in (404, 400):
+                        last_error = f"Model {target_model} not available ({response.status_code})"
+                        continue
+                    else:
+                        raise RuntimeError(f"Gemini API error ({response.status_code}): {response.text}")
+            except requests.exceptions.Timeout:
+                last_error = f"Model {target_model} request timed out"
+                continue
+            except Exception as e:
+                last_error = str(e)
+                continue
+
+        raise RuntimeError(f"Gemini generation error: {last_error or 'All model attempts failed'}")

{dbagent_cli-0.3.3 → dbagent_cli-0.3.5}/dbagent/ui/console.py

@@ -56,22 +56,37 @@ def print_code(code: str, language: str = "sql", title: Optional[str] = None) ->
     console.print(panel)
 
 
-def print_results_table(columns: List[str], rows: List[Dict[str, Any]], title: str = "Query Results") -> None:
-    """Print query results in a clean Rich table."""
-    if not columns:
-        console.print("[dim]Query returned no rows.[/dim]")
+def print_results_table(columns: List[str], rows: List[Dict[str, Any]], title: str = "Results") -> None:
+    """Print query results in a clean, readable Rich table with wide-table protection."""
+    if not columns or not rows:
+        console.print("[dim]Query returned 0 rows.[/dim]\n")
         return
 
-    table = Table(title=title, show_header=True, header_style="bold magenta", border_style="dim")
-    for col in columns:
-        table.add_column(str(col))
+    MAX_DISPLAY_COLS = 8
+    is_truncated = len(columns) > MAX_DISPLAY_COLS
+    display_cols = columns[:MAX_DISPLAY_COLS] if is_truncated else columns
+
+    table = Table(title=f"[bold cyan]{title}[/bold cyan]", show_header=True, header_style="bold magenta", border_style="dim")
+    
+    for col in display_cols:
+        table.add_column(str(col), overflow="ellipsis", max_width=35)
 
     for row in rows:
         row_vals = []
-        for col in columns:
+        for col in display_cols:
             v = row.get(col)
-            row_vals.append(str(v) if v is not None else "[dim]NULL[/dim]")
+            val_str = str(v) if v is not None else "[dim]NULL[/dim]"
+            # Clean up excessively long raw json/strings
+            if len(val_str) > 40:
+                val_str = val_str[:37] + "..."
+            row_vals.append(val_str)
         table.add_row(*row_vals)
 
+    console.print("")
     console.print(table)
-    console.print(f"[dim]Total rows: {len(rows)}[/dim]\n")
+    if is_truncated:
+        remaining = len(columns) - MAX_DISPLAY_COLS
+        console.print(f"[dim](Showing {MAX_DISPLAY_COLS} of {len(columns)} columns. Hidden: {', '.join(columns[MAX_DISPLAY_COLS:MAX_DISPLAY_COLS+5])}{'...' if remaining > 5 else ''})[/dim]")
+        console.print(f"[dim]Tip: Ask for specific fields (e.g., 'list id, username, email, status from ivis_user') for targeted view.[/dim]")
+    console.print(f"[bold green]Total rows:[/bold green] {len(rows)}\n")
+

{dbagent_cli-0.3.3 → dbagent_cli-0.3.5}/dbagent_cli.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: dbagent-cli
-Version: 0.3.3
-Summary: Enterprise AI Database Copilot with Instant Schema Caching & Zero-Latency Chat (CLI)
+Version: 0.3.5
+Summary: Production-Grade AI Database Copilot with Ultra-Fast Inference & Clean UI (CLI)
 Author: Santhosh Gupta
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{dbagent_cli-0.3.3 → dbagent_cli-0.3.5}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dbagent-cli"
-version = "0.3.3"
-description = "Enterprise AI Database Copilot with Instant Schema Caching & Zero-Latency Chat (CLI)"
+version = "0.3.5"
+description = "Production-Grade AI Database Copilot with Ultra-Fast Inference & Clean UI (CLI)"
 readme = "README.md"
 requires-python = ">=3.9"
 authors = [

dbagent_cli-0.3.3/dbagent/llm/gemini_provider.py

@@ -1,110 +0,0 @@
-"""
-Google Gemini Free Tier LLM Provider.
-Uses Gemini 2.0 Flash / Gemini 1.5 Flash via direct HTTP API.
-"""
-
-import json
-import os
-import requests
-from typing import Optional, Callable, List
-from dbagent.llm.base import BaseLLMProvider
-
-
-class GeminiProvider(BaseLLMProvider):
-    """Google Gemini LLM provider (Free Tier available)."""
-
-    def __init__(self, api_key: Optional[str] = None, default_model: str = "gemini-3.6-flash"):
-        self.api_key = api_key or os.getenv("GEMINI_API_KEY")
-        self.default_model = default_model
-
-    @property
-    def name(self) -> str:
-        return "gemini"
-
-    def is_available(self) -> bool:
-        return bool(self.api_key)
-
-    def list_models(self) -> List[str]:
-        return [
-            "gemini-3.6-flash",
-            "gemini-2.5-flash",
-            "gemini-2.5-pro",
-        ]
-
-    def generate(
-        self,
-        prompt: str,
-        system_prompt: Optional[str] = None,
-        model: Optional[str] = None,
-        stream_callback: Optional[Callable[[str], None]] = None,
-    ) -> str:
-        if not self.api_key:
-            raise ValueError(
-                "Gemini API key is not configured. Set GEMINI_API_KEY environment variable or run `db-agent config`."
-            )
-
-        target_model = model or self.default_model
-        # Strip model prefixes if provided
-        if target_model.startswith("models/"):
-            target_model = target_model[7:]
-
-        endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{target_model}:generateContent?key={self.api_key}"
-        if stream_callback:
-            endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{target_model}:streamGenerateContent?alt=sse&key={self.api_key}"
-
-        contents = []
-        if system_prompt:
-            contents.append({
-                "role": "user",
-                "parts": [{"text": f"System Instructions: {system_prompt}\n\nTask: {prompt}"}],
-            })
-        else:
-            contents.append({
-                "role": "user",
-                "parts": [{"text": prompt}],
-            })
-
-        payload = {
-            "contents": contents,
-            "generationConfig": {
-                "temperature": 0.1,
-            },
-        }
-
-        try:
-            if stream_callback:
-                response = requests.post(endpoint, json=payload, stream=True, timeout=90)
-                if response.status_code != 200:
-                    raise RuntimeError(f"Gemini API error ({response.status_code}): {response.text}")
-
-                full_text = []
-                for line in response.iter_lines():
-                    if line:
-                        decoded = line.decode("utf-8")
-                        if decoded.startswith("data: "):
-                            raw_json = decoded[6:]
-                            try:
-                                chunk = json.loads(raw_json)
-                                candidates = chunk.get("candidates", [])
-                                if candidates:
-                                    parts = candidates[0].get("content", {}).get("parts", [])
-                                    for p in parts:
-                                        t = p.get("text", "")
-                                        full_text.append(t)
-                                        stream_callback(t)
-                            except Exception:
-                                pass
-                return "".join(full_text)
-            else:
-                response = requests.post(endpoint, json=payload, timeout=90)
-                if response.status_code == 200:
-                    data = response.json()
-                    candidates = data.get("candidates", [])
-                    if candidates:
-                        parts = candidates[0].get("content", {}).get("parts", [])
-                        return "".join(p.get("text", "") for p in parts)
-                    return ""
-                else:
-                    raise RuntimeError(f"Gemini API error ({response.status_code}): {response.text}")
-        except Exception as e:
-            raise RuntimeError(f"Gemini generation error: {str(e)}")