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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbagent-cli
-Version: 0.9.8
+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.8 → 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.8"
+__version__ = "0.10.0"
 __author__ = "Santhosh Gupta"

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

@@ -530,6 +530,8 @@ def ask_command(
         choice_callback=_choice_callback,
     )
 
+    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]
 
@@ -541,15 +543,14 @@ def ask_command(
             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]")
-        try:
-            sys.stdout.write(chunk)
-            sys.stdout.flush()
-        except Exception:
-            pass
+        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()
 
@@ -616,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({
@@ -637,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,
@@ -653,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(":"):
@@ -702,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")
@@ -1006,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
@@ -1114,11 +1145,13 @@ 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
 
+            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]
 
@@ -1130,14 +1163,17 @@ def chat_command(
                     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]")
-                try:
-                    sys.stdout.write(chunk)
-                    sys.stdout.flush()
-                except Exception:
-                    pass
+                streamer.feed(chunk)
+
+            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()
 
-            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.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.8 → dbagent_cli-0.10.0}/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.10.0/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.8 → 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.8
+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.8 → 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
@@ -57,6 +58,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
@@ -73,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.8 → dbagent_cli-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dbagent-cli"
-version = "0.9.8"
+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