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

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

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

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

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

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

@@ -617,7 +617,7 @@ def chat_command(
         ":help", ":tables", ":schema", ":dt", ":table", ":fk", ":path", ":join",
         ":doctor", ":mode", ":changes", ":provider", ":model", ":models",
         ":page", ":card", ":wide", ":scroll", ":window", ":grid", ":web",
-        ":explain", ":history", ":auto", ":noauto", ":run", ":clear", ":export",
+        ":explain", ":history", ":queue", ":auto", ":noauto", ":run", ":clear", ":export",
         ":exit", ":quit", ":q",
     ], ignore_case=True)
     chat_style = Style.from_dict({
@@ -638,6 +638,9 @@ def chat_command(
     query_history: List[PipelineResult] = []
     last_result: Optional[PipelineResult] = None
 
+    from dbagent.execution.prompt_queue import PromptQueueManager
+    prompt_queue = PromptQueueManager(console=console)
+
     # Create pipeline ONCE and reuse across all queries (avoids re-init overhead)
     pipeline = QueryPipeline(
         connector=connector,
@@ -654,26 +657,37 @@ def chat_command(
         curr_model = model or getattr(llm, "default_model", "default")
         width = min(console.width or 100, 120)
         rule = "─" * (width - 1)
+        queue_count = prompt_queue.count()
+        queue_badge = f"  │  <style class='bottom-toolbar.cyan'>📥 Queued: {queue_count}</style>" if queue_count > 0 else ""
         return HTML(
             f"<ansidarkgray>{rule}</ansidarkgray>\n"
             f" <style class='bottom-toolbar.green'>● Connected:</style> <b>{db_name}</b> <i>({dialect} • {len(table_names)} tables)</i>  │  "
             f"<style class='bottom-toolbar.cyan'>🤖 AI:</style> <b>{curr_model}</b>  │  "
-            f"<style class='bottom-toolbar.yellow'>🛡️ {current_mode.value}</style>  │  "
+            f"<style class='bottom-toolbar.yellow'>🛡️ {current_mode.value}</style>{queue_badge}  │  "
             f"<b>:help</b> for commands · <b>:models</b> to switch"
         )
 
     while True:
         try:
-            width = min(console.width or 100, 120)
-            console.print(f"[dim cyan]{'─' * (width - 1)}[/dim cyan]")
-            user_input = session.prompt(
-                HTML("<ansicyan><b>❯</b></ansicyan> "),
-                bottom_toolbar=_get_bottom_toolbar,
-                rprompt=HTML(f"<ansidarkgray>db-agent v{__version__}</ansidarkgray>"),
-                placeholder=HTML("<ansidarkgray><i>Ask in plain English or paste direct SQL...</i></ansidarkgray>"),
-            ).strip()
-            if not user_input:
-                continue
+            if prompt_queue.has_next():
+                user_input = prompt_queue.pop_next()
+                rem = prompt_queue.count()
+                rem_str = f" [dim cyan]({rem} more in queue)[/dim cyan]" if rem > 0 else ""
+                console.print(f"\n[bold cyan]❯[/bold cyan] [bold white]{user_input}[/bold white] [bold yellow](Executing queued prompt)[/bold yellow]{rem_str}")
+            else:
+                width = min(console.width or 100, 120)
+                console.print(f"[dim cyan]{'─' * (width - 1)}[/dim cyan]")
+                user_input = session.prompt(
+                    HTML("<ansicyan><b>❯</b></ansicyan> "),
+                    bottom_toolbar=_get_bottom_toolbar,
+                    rprompt=HTML(f"<ansidarkgray>db-agent v{__version__}</ansidarkgray>"),
+                    placeholder=HTML("<ansidarkgray><i>Ask in plain English or paste direct SQL...</i></ansidarkgray>"),
+                ).strip()
+                if not user_input:
+                    continue
+
+                # Split chained prompts if user entered multiple commands like "prompt 1 ; prompt 2"
+                user_input = prompt_queue.split_and_enqueue_chained(user_input)
 
             # --- REPL commands (all start with :) ---
             if user_input.startswith(":"):
@@ -703,6 +717,7 @@ def chat_command(
                     cmd_table.add_row(":forget <id|topic>", "Remove a learned rule from persistent memory")
                     cmd_table.add_row(":mode <name>", "Switch safety mode (SAFE, CONFIRM, ADMIN, READ_ONLY)")
                     cmd_table.add_row(":history", "View session query history, execution timing & row counts")
+                    cmd_table.add_row(":queue, :q-list", "View queued in-line prompts (:queue clear to reset)")
                     cmd_table.add_row(":page <n>, :card", "Inspect wide multi-column query results")
                     cmd_table.add_row(":window, :web", "Open interactive desktop or browser data grid")
                     cmd_table.add_row(":explain", "Explain last generated SQL query with execution plan")
@@ -1007,6 +1022,21 @@ def chat_command(
                         print_warning("No previous query to explain.")
                     continue
 
+                if cmd_name in [":queue", ":q-list"]:
+                    if cmd_arg.lower() in ["clear", "cls", "reset"]:
+                        cleared_count = prompt_queue.clear()
+                        print_success(f"Cleared {cleared_count} queued prompt(s).")
+                    else:
+                        queued_items = prompt_queue.list_all()
+                        if not queued_items:
+                            console.print("[dim]No queued prompts in line. Chain prompts with ';' or type while streaming.[/dim]\n")
+                        else:
+                            console.print(f"\n[bold cyan]📥 Pending Prompts in Line ({len(queued_items)}):[/bold cyan]")
+                            for idx, q_item in enumerate(queued_items, 1):
+                                console.print(f"  [{idx}] [bold white]{q_item}[/bold white]")
+                            console.print("\n[dim]To clear queue: [bold]:queue clear[/bold][/dim]\n")
+                    continue
+
                 if cmd_name == ":history":
                     render_session_history(query_history)
                     continue
@@ -1115,7 +1145,7 @@ def chat_command(
                 console.print("[bold cyan]Goodbye![/bold cyan]")
                 break
 
-            # --- Natural language query via pipeline with live streaming ---
+            # --- Natural language query via pipeline with live streaming & background queue listener ---
             pipeline.model = model
             pipeline.mode = current_mode
             pipeline.auto_execute = auto_execute
@@ -1135,8 +1165,12 @@ def chat_command(
                     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)
+            prompt_queue.start_background_listener()
+            try:
+                with spinner:
+                    result = pipeline.run(user_prompt=user_input, stream_callback=_live_stream_callback)
+            finally:
+                prompt_queue.stop_background_listener()
 
             if stream_started[0]:
                 streamer.finalize()

dbagent_cli-0.10.0/dbagent/execution/prompt_queue.py

@@ -0,0 +1,152 @@
+"""
+In-Line Prompt Queue Manager for DB-Agent CLI.
+Allows users to queue follow-up prompts while a query is running or stream is active,
+and supports multi-prompt chaining using ';' or '&&'.
+"""
+
+import collections
+import os
+import re
+import sys
+import threading
+import time
+from typing import List, Optional, Callable
+from rich.console import Console
+
+
+class PromptQueueManager:
+    """
+    Thread-safe FIFO prompt queue with cross-platform background input listener.
+    Supports asynchronous queuing during active execution and multi-prompt chaining.
+    """
+
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+        self._queue = collections.deque()
+        self._lock = threading.Lock()
+        self._listener_thread: Optional[threading.Thread] = None
+        self._stop_listener = threading.Event()
+        self._current_line: List[str] = []
+
+    def enqueue(self, prompt: str, notify: bool = True) -> None:
+        """Add a prompt to the back of the queue."""
+        p = prompt.strip()
+        if not p:
+            return
+        with self._lock:
+            self._queue.append(p)
+        if notify:
+            self.console.print(f"\n[bold yellow]📥 Queued next in line:[/bold yellow] [bold white]\"{p}\"[/bold white]")
+
+    def has_next(self) -> bool:
+        """Check if there are any queued prompts waiting."""
+        with self._lock:
+            return len(self._queue) > 0
+
+    def pop_next(self) -> Optional[str]:
+        """Pop the next prompt from the front of the queue."""
+        with self._lock:
+            if self._queue:
+                return self._queue.popleft()
+        return None
+
+    def peek_next(self) -> Optional[str]:
+        """Peek at the next prompt without removing it."""
+        with self._lock:
+            if self._queue:
+                return self._queue[0]
+        return None
+
+    def list_all(self) -> List[str]:
+        """List all pending queued prompts."""
+        with self._lock:
+            return list(self._queue)
+
+    def count(self) -> int:
+        """Return the number of queued prompts."""
+        with self._lock:
+            return len(self._queue)
+
+    def clear(self) -> int:
+        """Clear all pending prompts from the queue and return count cleared."""
+        with self._lock:
+            cleared = len(self._queue)
+            self._queue.clear()
+            return cleared
+
+    def split_and_enqueue_chained(self, raw_input: str) -> str:
+        """
+        Split prompts separated by ';' or '&&' if not a raw SQL statement or inside quotes.
+        Returns the first prompt to execute immediately and enqueues the rest.
+        """
+        raw_clean = raw_input.strip()
+        if not raw_clean:
+            return raw_clean
+
+        # Do not split direct SQL statements like "SELECT 1; SELECT 2;"
+        if raw_clean.lower().startswith(("select ", "insert ", "update ", "delete ", "create ", "alter ", "drop ", "with ")):
+            return raw_clean
+
+        # Do not split special REPL commands
+        if raw_clean.startswith(":"):
+            return raw_clean
+
+        # Split by ';' or '&&'
+        delimiter_pattern = r'\s*(?:;|&&)\s*'
+        parts = [p.strip() for p in re.split(delimiter_pattern, raw_clean) if p.strip()]
+
+        if len(parts) > 1:
+            first_prompt = parts[0]
+            for remaining_prompt in parts[1:]:
+                self.enqueue(remaining_prompt, notify=True)
+            return first_prompt
+
+        return raw_clean
+
+    def start_background_listener(self) -> None:
+        """Start listening for keyboard input in the background while a task/stream runs."""
+        self._stop_listener.clear()
+        self._current_line = []
+        self._listener_thread = threading.Thread(target=self._listen_loop, daemon=True)
+        self._listener_thread.start()
+
+    def stop_background_listener(self) -> None:
+        """Stop the background listener thread."""
+        self._stop_listener.set()
+        if self._listener_thread:
+            self._listener_thread.join(timeout=0.15)
+            self._listener_thread = None
+
+    def _listen_loop(self) -> None:
+        """Cross-platform non-blocking input listener loop."""
+        is_windows = os.name == "nt"
+        if is_windows:
+            try:
+                import msvcrt
+                while not self._stop_listener.is_set():
+                    if msvcrt.kbhit():
+                        ch = msvcrt.getwch()
+                        if ch in ("\r", "\n"):
+                            line = "".join(self._current_line).strip()
+                            self._current_line = []
+                            if line:
+                                self.enqueue(line, notify=True)
+                        elif ch == "\b":
+                            if self._current_line:
+                                self._current_line.pop()
+                        elif ord(ch) >= 32:
+                            self._current_line.append(ch)
+                    time.sleep(0.02)
+            except Exception:
+                pass
+        else:
+            try:
+                import select
+                while not self._stop_listener.is_set():
+                    r, _, _ = select.select([sys.stdin], [], [], 0.05)
+                    if r:
+                        line = sys.stdin.readline().strip()
+                        if line:
+                            self.enqueue(line, notify=True)
+            except Exception:
+                pass

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

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

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

@@ -19,6 +19,7 @@ dbagent/execution/__init__.py
 dbagent/execution/cache.py
 dbagent/execution/changeset.py
 dbagent/execution/cost.py
+dbagent/execution/prompt_queue.py
 dbagent/execution/recovery.py
 dbagent/execution/sandbox.py
 dbagent/execution/streaming.py
@@ -74,6 +75,7 @@ tests/test_doctor_and_viz.py
 tests/test_generator.py
 tests/test_graph.py
 tests/test_knowledge.py
+tests/test_prompt_queue.py
 tests/test_providers.py
 tests/test_recovery.py
 tests/test_safety.py

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

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

dbagent_cli-0.10.0/tests/test_prompt_queue.py

@@ -0,0 +1,80 @@
+"""
+Unit tests for In-Line Prompt Queue Manager.
+"""
+
+import pytest
+from dbagent.execution.prompt_queue import PromptQueueManager
+
+
+def test_prompt_queue_fifo():
+    qm = PromptQueueManager()
+    assert qm.count() == 0
+    assert not qm.has_next()
+
+    qm.enqueue("first prompt", notify=False)
+    qm.enqueue("second prompt", notify=False)
+
+    assert qm.count() == 2
+    assert qm.has_next()
+    assert qm.peek_next() == "first prompt"
+    assert qm.pop_next() == "first prompt"
+    assert qm.count() == 1
+    assert qm.pop_next() == "second prompt"
+    assert qm.count() == 0
+    assert not qm.has_next()
+
+
+def test_split_and_enqueue_chained():
+    qm = PromptQueueManager()
+    raw = "how ivis_user and ivis_site were linked ; give the flow diagram ; count total users"
+    first = qm.split_and_enqueue_chained(raw)
+
+    assert first == "how ivis_user and ivis_site were linked"
+    assert qm.count() == 2
+    assert qm.list_all() == ["give the flow diagram", "count total users"]
+
+
+def test_split_and_enqueue_double_ampersand():
+    qm = PromptQueueManager()
+    raw = "show active tenants && list users in tenant 1"
+    first = qm.split_and_enqueue_chained(raw)
+
+    assert first == "show active tenants"
+    assert qm.count() == 1
+    assert qm.pop_next() == "list users in tenant 1"
+
+
+def test_do_not_split_sql():
+    qm = PromptQueueManager()
+    sql_prompt = "SELECT * FROM users WHERE id = 1; SELECT * FROM sites;"
+    res = qm.split_and_enqueue_chained(sql_prompt)
+    assert res == sql_prompt
+    assert qm.count() == 0
+
+
+def test_do_not_split_repl_commands():
+    qm = PromptQueueManager()
+    cmd = ":learn tenant_rule = all users belong to tenants"
+    res = qm.split_and_enqueue_chained(cmd)
+    assert res == cmd
+    assert qm.count() == 0
+
+
+def test_prompt_queue_clear():
+    qm = PromptQueueManager()
+    qm.enqueue("item 1", notify=False)
+    qm.enqueue("item 2", notify=False)
+    assert qm.count() == 2
+
+    cleared = qm.clear()
+    assert cleared == 2
+    assert qm.count() == 0
+    assert not qm.has_next()
+
+
+def test_background_listener_lifecycle():
+    qm = PromptQueueManager()
+    qm.start_background_listener()
+    assert qm._listener_thread is not None
+    qm.stop_background_listener()
+    assert qm._listener_thread is None