dbagent-cli 0.9.7__tar.gz → 0.9.9__tar.gz

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbagent-cli
-Version: 0.9.7
+Version: 0.9.9
 Summary: Enterprise AI Database Copilot, Schema Graph Introspector & Autonomous Recovery Agent (CLI)
 Author: Santhosh Gupta
 Requires-Python: >=3.9

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent/__init__.py

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

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent/agent/generator.py

@@ -247,6 +247,7 @@ class ScriptGenerator:
         user_prompt: str,
         conversation_history: Optional[str] = None,
         model: Optional[str] = None,
+        stream_callback: Optional[Callable[[str], None]] = None,
     ) -> str:
         """Generate a natural conversational response to the user's message with full session memory."""
         table_names = [t.name for t in schema.tables]
@@ -268,6 +269,7 @@ class ScriptGenerator:
             prompt=full_prompt,
             system_prompt=system_prompt,
             model=model,
+            stream_callback=stream_callback,
         )
 
     def generate_analysis_response(
@@ -276,6 +278,7 @@ class ScriptGenerator:
         user_prompt: str,
         conversation_history: Optional[str] = None,
         model: Optional[str] = None,
+        stream_callback: Optional[Callable[[str], None]] = None,
     ) -> str:
         """Generate a comprehensive architectural analysis report with ASCII diagrams, theory, and SQL queries."""
         # 1. Filter relevant tables including foreign keys and junction tables
@@ -301,6 +304,7 @@ class ScriptGenerator:
             prompt=full_prompt,
             system_prompt=system_prompt,
             model=model,
+            stream_callback=stream_callback,
         )
 
     # --- Full generation (for `generate` command) ---

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent/agent/pipeline.py

@@ -56,6 +56,7 @@ class PipelineResult:
     # Conversational chat response
     is_chat: bool = False
     is_direct_sql: bool = False
+    was_streamed: bool = False
     message: str = ""
     # Query classification
     query_type: str = "unknown"  # read, write, ddl, chat, unknown
@@ -192,7 +193,13 @@ class QueryPipeline:
         retriever = ContextRetriever(targeted)
         return retriever.retrieve_context(user_prompt, exact_tables=exact, fuzzy_tables=fuzzy, max_tables=12)
 
-    def run(self, user_prompt: str, force: bool = False, bypass_cache: bool = False) -> PipelineResult:
+    def run(
+        self,
+        user_prompt: str,
+        force: bool = False,
+        bypass_cache: bool = False,
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> PipelineResult:
         """
         Executes end-to-end pipeline: Prompt -> Security/Semantics -> SQL -> Safe Exec -> Results.
         """
@@ -217,7 +224,10 @@ class QueryPipeline:
                     user_prompt=user_prompt,
                     conversation_history=conv_history,
                     model=self.model,
+                    stream_callback=stream_callback,
                 )
+                if stream_callback:
+                    result.was_streamed = True
                 result.is_chat = True
                 result.was_executed = True
                 result.query_type = "chat"
@@ -273,7 +283,10 @@ class QueryPipeline:
                     user_prompt=analysis_prompt,
                     conversation_history=conv_history,
                     model=self.model,
+                    stream_callback=stream_callback,
                 )
+                if stream_callback:
+                    result.was_streamed = True
                 result.ground_truth = SchemaGroundTruthValidator.validate_response(result.message, sub_schema)
                 result.is_chat = True
                 result.was_executed = True

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent/cli.py

@@ -339,7 +339,10 @@ def _display_pipeline_result(result: PipelineResult, show_sql: bool = True) -> N
 
     if result.is_chat and result.message:
         console.print("")
-        console.print(Markdown(result.message))
+        if not result.was_streamed:
+            console.print(Markdown(result.message))
+        if result.ground_truth:
+            console.print(result.ground_truth.format_summary())
         if result.execution_time_ms > 0:
             print_timing(result.execution_time_ms)
         console.print("")
@@ -527,8 +530,26 @@ def ask_command(
         choice_callback=_choice_callback,
     )
 
-    with DynamicSpinner():
-        result = pipeline.run(user_prompt=prompt, force=force, bypass_cache=no_cache)
+    from dbagent.ui.live_streamer import LiveMarkdownStreamer
+    streamer = LiveMarkdownStreamer(console)
+    spinner = DynamicSpinner.for_prompt(prompt, model_name=model or getattr(llm, "default_model", None), connector=connector)
+    stream_started = [False]
+
+    def _query_stream_callback(chunk: str) -> None:
+        if not stream_started[0]:
+            stream_started[0] = True
+            spinner.pause()
+            timing_str = f"⚡ {spinner.elapsed_ms / 1000:.2f}s" if spinner.elapsed_ms > 0 else ""
+            active_model = model or getattr(llm, "default_model", None)
+            model_display = f" ({active_model})" if active_model else ""
+            console.print(f"\n[bold cyan]● DB-Agent{model_display}[/bold cyan] [dim]{timing_str}[/dim]")
+        streamer.feed(chunk)
+
+    with spinner:
+        result = pipeline.run(user_prompt=prompt, force=force, bypass_cache=no_cache, stream_callback=_query_stream_callback)
+
+    if stream_started[0]:
+        streamer.finalize()
 
     _display_pipeline_result(result, show_sql=True)
     connector.close()
@@ -1094,14 +1115,31 @@ def chat_command(
                 console.print("[bold cyan]Goodbye![/bold cyan]")
                 break
 
-            # --- Natural language query via pipeline ---
-            # Update pipeline settings in-place (pipeline was created once before the loop)
+            # --- Natural language query via pipeline with live streaming ---
             pipeline.model = model
             pipeline.mode = current_mode
             pipeline.auto_execute = auto_execute
 
-            with DynamicSpinner.for_prompt(user_input, model_name=model or getattr(llm, "default_model", None), connector=connector):
-                result = pipeline.run(user_prompt=user_input)
+            from dbagent.ui.live_streamer import LiveMarkdownStreamer
+            streamer = LiveMarkdownStreamer(console)
+            spinner = DynamicSpinner.for_prompt(user_input, model_name=model or getattr(llm, "default_model", None), connector=connector)
+            stream_started = [False]
+
+            def _live_stream_callback(chunk: str) -> None:
+                if not stream_started[0]:
+                    stream_started[0] = True
+                    spinner.pause()
+                    timing_str = f"⚡ {spinner.elapsed_ms / 1000:.2f}s" if spinner.elapsed_ms > 0 else ""
+                    active_model = model or getattr(llm, "default_model", None)
+                    model_display = f" ({active_model})" if active_model else ""
+                    console.print(f"\n[bold cyan]● DB-Agent{model_display}[/bold cyan] [dim]{timing_str}[/dim]")
+                streamer.feed(chunk)
+
+            with spinner:
+                result = pipeline.run(user_prompt=user_input, stream_callback=_live_stream_callback)
+
+            if stream_started[0]:
+                streamer.finalize()
 
             render_assistant_turn(
                 result,

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent/schema/ground_truth.py

@@ -85,17 +85,19 @@ class SchemaGroundTruthValidator:
                         if fk_desc not in result.verified_fks:
                             result.verified_fks.append(fk_desc)
 
-        # 2. Extract and validate SQL queries against physical schema
-        sql_blocks = re.findall(r'```(?:sql)?\s*([\s\S]*?)\s*```', response_text, re.IGNORECASE)
+        # 2. Extract and validate only actual SQL queries against physical schema
+        sql_blocks = re.findall(r'```(?:sql)\s*([\s\S]*?)\s*```', response_text, re.IGNORECASE)
         result.sql_queries_checked = len(sql_blocks)
         sql_referenced_tables = set()
+        sql_ignore_keywords = {"via", "lateral", "on", "using", "where", "select", "table", "as", "and", "or", "values"}
 
         for block in sql_blocks:
             # Extract FROM and JOIN table references
             matches = re.findall(r'\b(?:FROM|JOIN)\s+([a-zA-Z0-9_]+)', block, re.IGNORECASE)
             for m in matches:
                 m_clean = m.strip().lower()
-                sql_referenced_tables.add(m_clean)
+                if m_clean not in sql_ignore_keywords:
+                    sql_referenced_tables.add(m_clean)
 
         for sql_tbl in sql_referenced_tables:
             if sql_tbl in schema_table_map:

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent/ui/chat_screen.py

@@ -114,8 +114,15 @@ def render_assistant_turn(
         model_display = f" ({ai_model})" if ai_model else ""
         agent_title = f"[bold cyan]● DB-Agent{model_display}[/bold cyan] [dim]{timing_str}[/dim]"
     
-    # Conversational Chat Response
+    # Conversational Chat / Architectural Analysis Response
     if result.is_chat and result.message:
+        if result.was_streamed:
+            console.print("")
+            if result.ground_truth:
+                console.print(result.ground_truth.format_summary())
+            console.print("")
+            return
+
         console.print(f"\n{agent_title}")
         console.print(Markdown(result.message))
         if result.ground_truth:

dbagent_cli-0.9.9/dbagent/ui/live_streamer.py

@@ -0,0 +1,117 @@
+"""
+Real-Time Line-Buffered Rich Markdown Streamer for DB-Agent CLI.
+Renders markdown headers, formatted diagram panels, syntax-highlighted SQL blocks,
+and sleek bulleted lists dynamically as tokens stream in from LLM providers.
+"""
+
+import re
+import sys
+from typing import List, Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.rule import Rule
+
+
+class LiveMarkdownStreamer:
+    """
+    Line-buffered dynamic terminal renderer for streaming LLM responses.
+    Renders syntax-highlighted code blocks, bordered ASCII diagrams,
+    styled markdown headers, and clean bullet lists live as tokens arrive.
+    """
+
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+        self.buffer = ""
+        self.in_code_block = False
+        self.code_lang = ""
+        self.code_lines: List[str] = []
+        self._has_started = False
+
+    def feed(self, chunk: str) -> None:
+        """Feed a token chunk from the LLM stream."""
+        self._has_started = True
+        self.buffer += chunk
+        while "\n" in self.buffer:
+            line, self.buffer = self.buffer.split("\n", 1)
+            self._process_line(line)
+
+    def _process_line(self, line: str) -> None:
+        line_strip = line.strip()
+
+        # Code block fence (```sql, ```text, ```)
+        if line_strip.startswith("```"):
+            if self.in_code_block:
+                # Close code block
+                self.in_code_block = False
+                code_text = "\n".join(self.code_lines)
+                lang = self.code_lang or "sql"
+                if lang in ["sql", "postgres", "postgresql", "mysql", "sqlite", "tsql"]:
+                    syntax = Syntax(code_text, "sql", theme="monokai", line_numbers=False)
+                    self.console.print(Panel(syntax, title="[dim]SQL Statement[/dim]", title_align="left", border_style="dim", padding=(0, 1)))
+                else:
+                    syntax = Syntax(code_text, "text", theme="monokai", line_numbers=False)
+                    self.console.print(Panel(syntax, title="[dim]Architecture Flow Diagram[/dim]", title_align="left", border_style="cyan", padding=(0, 1)))
+                self.code_lines = []
+                self.code_lang = ""
+            else:
+                # Open code block
+                self.in_code_block = True
+                self.code_lang = line_strip[3:].strip().lower()
+                self.code_lines = []
+            return
+
+        if self.in_code_block:
+            self.code_lines.append(line)
+            return
+
+        # Markdown Section Headers (#, ##, ###)
+        if line_strip.startswith("#"):
+            header_text = line_strip.lstrip("#").strip()
+            self.console.print("")
+            self.console.print(f"[bold cyan]{header_text}[/bold cyan]")
+            return
+
+        # Markdown Horizontal Rules (---, ***, ___)
+        if line_strip in ["---", "***", "___"]:
+            self.console.print(Rule(style="dim cyan"))
+            return
+
+        # Markdown Bullet Points (- , * , • )
+        if line_strip.startswith(("- ", "* ", "• ")):
+            content = line_strip[2:].strip()
+            styled = re.sub(r'\*\*(.*?)\*\*', r'[bold cyan]\1[/bold cyan]', content)
+            styled = re.sub(r'`(.*?)`', r'[bold white]\1[/bold white]', styled)
+            self.console.print(f"  [dim]•[/dim] {styled}")
+            return
+
+        # Numbered List items (1. , 2. )
+        num_match = re.match(r'^(\d+[\.\)])\s+(.*)', line_strip)
+        if num_match:
+            num_prefix, content = num_match.groups()
+            styled = re.sub(r'\*\*(.*?)\*\*', r'[bold cyan]\1[/bold cyan]', content)
+            styled = re.sub(r'`(.*?)`', r'[bold white]\1[/bold white]', styled)
+            self.console.print(f" [bold yellow]{num_prefix}[/bold yellow] {styled}")
+            return
+
+        # Blank Line
+        if not line_strip:
+            self.console.print("")
+            return
+
+        # Regular Markdown paragraph text with bold and inline code styling
+        styled_line = re.sub(r'\*\*(.*?)\*\*', r'[bold cyan]\1[/bold cyan]', line)
+        styled_line = re.sub(r'`(.*?)`', r'[bold white]\1[/bold white]', styled_line)
+        self.console.print(styled_line)
+
+    def finalize(self) -> None:
+        """Flush remaining buffer and close any dangling open blocks."""
+        if self.buffer.strip():
+            self._process_line(self.buffer)
+        if self.in_code_block and self.code_lines:
+            code_text = "\n".join(self.code_lines)
+            syntax = Syntax(code_text, self.code_lang or "sql", theme="monokai", line_numbers=False)
+            self.console.print(Panel(syntax, border_style="dim", padding=(0, 1)))
+        self.buffer = ""
+        self.code_lines = []
+        self.in_code_block = False

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbagent-cli
-Version: 0.9.7
+Version: 0.9.9
 Summary: Enterprise AI Database Copilot, Schema Graph Introspector & Autonomous Recovery Agent (CLI)
 Author: Santhosh Gupta
 Requires-Python: >=3.9

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/dbagent_cli.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ dbagent/sql/validator.py
 dbagent/ui/chat_screen.py
 dbagent/ui/console.py
 dbagent/ui/grid_window.py
+dbagent/ui/live_streamer.py
 dbagent/ui/viewer.py
 dbagent/ui/visualizer.py
 dbagent_cli.egg-info/PKG-INFO

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dbagent-cli"
-version = "0.9.7"
+version = "0.9.9"
 description = "Enterprise AI Database Copilot, Schema Graph Introspector & Autonomous Recovery Agent (CLI)"
 readme = "README.md"
 requires-python = ">=3.9"

{dbagent_cli-0.9.7 → dbagent_cli-0.9.9}/tests/test_cli.py

@@ -481,6 +481,25 @@ def test_cli_changes_and_audit_commands():
     assert res_audit.exit_code == 0
 
 
+def test_pipeline_streaming_callback(sample_db: str):
+    from dbagent.connectors.factory import create_connector
+    from dbagent.llm.mock_provider import MockProvider
+    from dbagent.agent.pipeline import QueryPipeline
+
+    connector = create_connector(sample_db)
+    llm = MockProvider()
+    pipeline = QueryPipeline(connector=connector, llm=llm)
+
+    chunks = []
+    def callback(token: str):
+        chunks.append(token)
+
+    result = pipeline.run("hello assistant", stream_callback=callback)
+    assert result.was_streamed is True
+    assert result.is_chat is True
+    connector.close()
+
+
 def test_cli_recovery_commands():
     res_list = runner.invoke(app, ["recovery", "list"])
     assert res_list.exit_code == 0
@@ -491,5 +510,3 @@ def test_cli_recovery_commands():
 
     res_cleanup = runner.invoke(app, ["recovery", "cleanup"])
     assert res_cleanup.exit_code == 0
-
-