abstractassistant 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

abstractassistant/app.py

@@ -6,6 +6,8 @@ Handles system tray integration, UI coordination, and application lifecycle.
 
 import threading
 import time
+import signal
+from pathlib import Path
 from typing import Optional
 
 import pystray
@@ -131,17 +133,26 @@ class EnhancedClickableIcon(pystray.Icon):
 class AbstractAssistantApp:
     """Main application class coordinating all components."""
     
-    def __init__(self, config: Optional[Config] = None, debug: bool = False, listening_mode: str = "wait"):
+    def __init__(
+        self,
+        config: Optional[Config] = None,
+        debug: bool = False,
+        listening_mode: str = "wait",
+        *,
+        data_dir: Optional[Path] = None,
+    ):
         """Initialize the AbstractAssistant application.
 
         Args:
             config: Configuration object (uses default if None)
             debug: Enable debug mode
             listening_mode: Voice listening mode (none, stop, wait, full)
+            data_dir: Assistant base data dir (sessions + runtime stores)
         """
         self.config = config or Config.default()
         self.debug = debug
         self.listening_mode = listening_mode
+        self.data_dir = Path(data_dir).expanduser() if data_dir is not None else None
         
         # Validate configuration
         if not self.config.validate():
@@ -152,7 +163,7 @@ class AbstractAssistantApp:
         # Initialize components
         self.icon: Optional[pystray.Icon] = None
         self.bubble_manager: Optional[QtBubbleManager] = None
-        self.llm_manager: LLMManager = LLMManager(config=self.config, debug=self.debug)
+        self.llm_manager: LLMManager = LLMManager(config=self.config, debug=self.debug, data_dir=self.data_dir)
         self.icon_generator: IconGenerator = IconGenerator(size=self.config.system_tray.icon_size)
         
         # Application state
@@ -786,6 +797,20 @@ class AbstractAssistantApp:
         
         if self.icon:
             self.icon.stop()
+
+        # Stop/hide Qt tray icon if we are running in Qt mode.
+        try:
+            if hasattr(self, "qt_tray_icon") and self.qt_tray_icon is not None:
+                self.qt_tray_icon.hide()
+        except Exception:
+            pass
+
+        # Stop click timer used for single/double click detection (Qt mode).
+        try:
+            if hasattr(self, "click_timer") and self.click_timer is not None:
+                self.click_timer.stop()
+        except Exception:
+            pass
         
         # Clean up bubble manager
         if self.bubble_manager:
@@ -797,6 +822,20 @@ class AbstractAssistantApp:
         
         if self.debug:
             print("✅ AbstractAssistant quit successfully")
+
+    def _request_qt_quit(self) -> None:
+        """Request a graceful quit on the Qt event loop (safe to call from SIGINT handler)."""
+        # Always run cleanup first; then quit the Qt event loop.
+        try:
+            self.quit_application()
+        except Exception:
+            pass
+
+        try:
+            if hasattr(self, "qt_app") and self.qt_app:
+                self.qt_app.quit()
+        except Exception:
+            pass
     
     def run(self):
         """Start the application using Qt event loop for proper threading."""
@@ -833,15 +872,39 @@ class AbstractAssistantApp:
                 print("AbstractAssistant started. Check your menu bar!")
                 print("Click the icon to open the chat interface.")
 
+            # Ctrl+C / SIGTERM should shut down cleanly (avoid macOS "python quit unexpectedly").
+            # We schedule the quit on the Qt loop to keep teardown ordered.
+            def _handle_sigint(_signum, _frame):
+                try:
+                    QTimer.singleShot(0, self._request_qt_quit)
+                except Exception:
+                    self._request_qt_quit()
+
+            try:
+                signal.signal(signal.SIGINT, _handle_sigint)
+                signal.signal(signal.SIGTERM, _handle_sigint)
+            except Exception:
+                # If signals are not available/allowed in this context, we still handle KeyboardInterrupt below.
+                pass
+
             # Run Qt event loop (this blocks until quit)
-            self.qt_app.exec_()
+            try:
+                self.qt_app.exec_()
+            except KeyboardInterrupt:
+                # Ensure a graceful shutdown when Ctrl+C interrupts the event loop.
+                self._request_qt_quit()
+                return
 
         except ImportError:
             if self.debug:
                 print("❌ PyQt5 not available. Falling back to pystray...")
             # Fallback to original pystray implementation
             self.icon = self.create_system_tray_icon()
-            self.icon.run()
+            try:
+                self.icon.run()
+            except KeyboardInterrupt:
+                self.quit_application()
+                return
 
     def _create_qt_system_tray_icon(self):
         """Create Qt-based system tray icon with smooth animations."""
@@ -996,5 +1059,5 @@ class AbstractAssistantApp:
         if self.debug:
             print("🔄 Qt: Quit requested")
 
-        if hasattr(self, 'qt_app') and self.qt_app:
-            self.qt_app.quit()
+        # Route through the same cleanup path (menu Quit should behave like Ctrl+C).
+        self._request_qt_quit()

abstractassistant/cli.py

@@ -1,76 +1,47 @@
 #!/usr/bin/env python3
-"""
-CLI entry point for AbstractAssistant.
+"""CLI entry point for AbstractAssistant.
 
-This module provides the command-line interface for launching AbstractAssistant.
+Packaging invariant:
+- `assistant --help` must not import GUI/voice stacks (optional dependencies).
 """
 
-import sys
+from __future__ import annotations
+
 import argparse
+import sys
 from pathlib import Path
 from typing import Optional
 
-from .app import AbstractAssistantApp
-from .config import Config
-
 
 def create_parser() -> argparse.ArgumentParser:
     """Create the command-line argument parser."""
-    parser = argparse.ArgumentParser(
-        prog="assistant",
-        description="AbstractAssistant - AI at your fingertips",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  assistant                    # Launch with default settings
-  assistant --config custom.toml  # Use custom config file
-  assistant --provider openai     # Set default provider
-  assistant --model gpt-4o        # Set default model
-  assistant --debug               # Enable debug mode
-
-For more information, visit: https://github.com/yourusername/abstractassistant
-        """,
-    )
+    prog = Path(sys.argv[0]).name if sys.argv and sys.argv[0] else "abstractassistant"
+    parser = argparse.ArgumentParser(prog=prog, description="AbstractAssistant (agentic tray + CLI)")
     
-    parser.add_argument(
-        "--config",
-        type=str,
-        help="Path to configuration file (default: config.toml)",
-        default=None,
-    )
+    parser.add_argument("--version", action="version", version="abstractassistant (agentic) v1")
     
-    parser.add_argument(
-        "--provider",
-        type=str,
-        choices=["lmstudio", "openai", "anthropic", "ollama"],
-        help="Default LLM provider",
-    )
+    parser.add_argument("--config", type=str, default=None, help="Path to config.toml (optional)")
+    parser.add_argument("--provider", type=str, default=None, help="LLM provider id (e.g. ollama, lmstudio, openai)")
+    parser.add_argument("--model", type=str, default=None, help="Model name/id for the provider")
+    parser.add_argument("--agent", type=str, default=None, choices=["react", "codeact", "memact"], help="Agent kind")
+    parser.add_argument("--data-dir", type=str, default=None, help="Assistant data dir (runtime stores + session)")
+    parser.add_argument("--workspace-root", type=str, default=None, help="Workspace root for filesystem-ish tools")
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
     
-    parser.add_argument(
-        "--model",
-        type=str,
-        help="Default model name",
-    )
+    sub = parser.add_subparsers(dest="command")
     
-    parser.add_argument(
-        "--debug",
-        action="store_true",
-        help="Enable debug mode",
-    )
-
-    parser.add_argument(
+    tray = sub.add_parser("tray", help="Run the macOS tray app")
+    tray.add_argument(
         "--listening-mode",
         type=str,
-        choices=["none", "stop", "wait", "full"],
-        help="Voice listening mode (none: no STT, stop: continuous listen/stop on 'STOP' keyword, wait: listen when TTS idle, full: continuous listen/interrupt on any speech)",
+        choices=["none", "stop", "wait", "full", "ptt"],
         default="wait",
+        help="Voice listening mode (requires [full] extra for STT/TTS)",
     )
-    
-    parser.add_argument(
-        "--version",
-        action="version",
-        version="AbstractAssistant 1.0.0",
-    )
+
+    run = sub.add_parser("run", help="Run one agentic turn in the terminal")
+    run.add_argument("--prompt", type=str, required=True, help="User prompt text")
+    run.add_argument("--approve-all-tools", action="store_true", help="Auto-approve all tool calls (dangerous)")
     
     return parser
 
@@ -103,37 +74,84 @@ def main() -> int:
     args = parser.parse_args()
     
     try:
-        # Load configuration
-        config_file = find_config_file(args.config)
-        if config_file:
-            config = Config.from_file(config_file)
-            if args.debug:
-                print(f"Loaded config from: {config_file}")
-        else:
-            config = Config.default()
-            if args.debug:
-                print("Using default configuration")
-        
-        # Override config with CLI arguments
-        if args.provider:
-            config.llm.default_provider = args.provider
-        if args.model:
-            config.llm.default_model = args.model
-        
-        # Create and run the application
-        app = AbstractAssistantApp(config=config, debug=args.debug, listening_mode=args.listening_mode)
-        
-        print("🤖 Starting AbstractAssistant...")
-        print("Look for the icon in your macOS menu bar!")
-        
-        if args.debug:
-            print("Debug mode enabled")
-            print(f"Provider: {config.llm.default_provider}")
-            print(f"Model: {config.llm.default_model}")
-            print(f"Listening mode: {args.listening_mode}")
-        
+        command = args.command or "tray"
+
+        if command == "run":
+            from .core.agent_host import AgentHost, AgentHostConfig
+
+            provider = str(args.provider or "ollama")
+            model = str(args.model or "qwen3:4b-instruct")
+            agent_kind = str(args.agent or "react")
+            data_dir = Path(args.data_dir).expanduser() if args.data_dir else (Path.home() / ".abstractassistant")
+
+            host = AgentHost(
+                AgentHostConfig(
+                    provider=provider,
+                    model=model,
+                    agent_kind=agent_kind,
+                    data_dir=data_dir,
+                    workspace_root=args.workspace_root,
+                )
+            )
+
+            def _approve(tool_calls):
+                if args.approve_all_tools:
+                    return True
+                # Prompt for dangerous/unknown batches; safe-only batches auto-approve.
+                if not host.tool_policy.requires_approval(tool_calls):
+                    return True
+                print("\nTool approval required:")
+                for tc in tool_calls:
+                    name = tc.get("name")
+                    arguments = tc.get("arguments")
+                    print(f"- {name}({arguments})")
+                ans = input("Approve this batch? [y/N] ").strip().lower()
+                return ans in {"y", "yes"}
+
+            def _ask_user(wait):
+                prompt = str(getattr(wait, "prompt", "") or "Input required:")
+                return input(f"\n{prompt}\n> ").strip()
+
+            final = ""
+            for ev in host.run_turn(user_text=args.prompt, approve_tools=_approve, ask_user=_ask_user):
+                typ = ev.get("type")
+                if typ == "assistant":
+                    final = str(ev.get("content") or "")
+                if typ == "error":
+                    raise RuntimeError(str(ev.get("error") or "error"))
+            print(final)
+            return 0
+
+        # tray (default)
+        try:
+            from .config import Config  # lightweight
+
+            config_file = find_config_file(args.config)
+            config = Config.from_file(config_file) if config_file else Config.default()
+            if args.provider:
+                config.llm.default_provider = str(args.provider)
+            if args.model:
+                config.llm.default_model = str(args.model)
+        except Exception:
+            config = None
+
+        try:
+            from .app import AbstractAssistantApp
+        except Exception as e:
+            print("AbstractAssistant tray mode requires GUI dependencies.")
+            print('Install (tray): pip install -U "abstractassistant"')
+            print('Install (tray + voice): pip install -U "abstractassistant[full]"')
+            print('From source (editable): pip install -e ".[lite]"')
+            print(f"Import error: {e}")
+            return 2
+
+        app = AbstractAssistantApp(
+            config=config,
+            debug=bool(args.debug),
+            listening_mode=str(getattr(args, "listening_mode", "wait")),
+            data_dir=Path(args.data_dir).expanduser() if getattr(args, "data_dir", None) else None,
+        )
         app.run()
-        
         return 0
         
     except KeyboardInterrupt:
@@ -141,8 +159,9 @@ def main() -> int:
         return 0
     except Exception as e:
         print(f"❌ Error starting AbstractAssistant: {e}")
-        if args.debug:
+        if getattr(args, "debug", False):
             import traceback
+
             traceback.print_exc()
         return 1