signalpilot-ai-internal 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

signalpilot_ai_internal/handlers.py

@@ -12,6 +12,7 @@ from .cache_service import get_cache_service
 from .cache_handlers import ChatHistoriesHandler, AppValuesHandler, CacheInfoHandler
 from .unified_database_schema_service import UnifiedDatabaseSchemaHandler, UnifiedDatabaseQueryHandler
 from .snowflake_schema_service import SnowflakeSchemaHandler, SnowflakeQueryHandler
+from .file_scanner_service import get_file_scanner_service
 from .schema_search_service import SchemaSearchHandler
 
 
@@ -258,6 +259,253 @@ class ReadAllFilesHandler(APIHandler):
         return '\n'.join(lines)
 
 
+class SelectFolderHandler(APIHandler):
+    """Handler to open a native folder picker and return the selected absolute path"""
+    
+    # Class-level flag to prevent multiple dialogs
+    _dialog_open = False
+
+    @tornado.web.authenticated
+    def get(self):
+        # Check if a dialog is already open
+        if SelectFolderHandler._dialog_open:
+            self.set_status(409)  # Conflict status
+            self.finish(json.dumps({
+                "error": "A folder selection dialog is already open"
+            }))
+            return
+            
+        try:
+            import tkinter as tk
+            from tkinter import filedialog
+            import threading
+            import time
+
+            # Set flag to prevent multiple dialogs
+            SelectFolderHandler._dialog_open = True
+            
+            # Create a fresh tkinter instance
+            root = tk.Tk()
+            
+            # Position the root window in the center of the screen BEFORE withdrawing
+            try:
+                # Get screen dimensions
+                screen_width = root.winfo_screenwidth()
+                screen_height = root.winfo_screenheight()
+                
+                # Calculate center position
+                x = (screen_width // 2) - 200  # Dialog is roughly 400px wide
+                y = (screen_height // 2) - 150  # Dialog is roughly 300px tall
+                
+                # Set window position and make it visible briefly for positioning
+                root.geometry(f"400x300+{x}+{y}")
+                root.update_idletasks()
+                
+                # Now withdraw the window
+                root.withdraw()
+                
+                # Enhanced topmost settings for better visibility
+                root.attributes('-topmost', True)
+                root.lift()
+                root.focus_force()
+                
+                # Final positioning update
+                root.update_idletasks()
+            except Exception:
+                # Fallback: just withdraw if positioning fails
+                root.withdraw()
+
+            folder = None
+            
+            try:
+                # Show the dialog with proper positioning
+                folder = filedialog.askdirectory(
+                    parent=root,
+                    title="Select Folder",
+                    initialdir=os.path.expanduser("~")  # Start in user's home directory
+                )
+            except Exception as e:
+                raise e
+            finally:
+                # Comprehensive cleanup
+                try:
+                    # Force close and destroy all tkinter components
+                    root.quit()
+                    root.destroy()
+                    
+                    # Additional cleanup for macOS - ensure complete destruction
+                    try:
+                        root.update_idletasks()
+                        root.update()
+                        # Force garbage collection of tkinter objects
+                        import gc
+                        gc.collect()
+                    except Exception:
+                        pass
+                        
+                except Exception:
+                    pass
+                finally:
+                    # Reset flag and add small delay to ensure cleanup
+                    SelectFolderHandler._dialog_open = False
+                    time.sleep(0.1)  # Small delay to ensure cleanup completes
+
+            # Normalize and return absolute path or null
+            if folder:
+                folder_path = os.path.abspath(folder)
+                self.finish(json.dumps({"path": folder_path}))
+            else:
+                self.finish(json.dumps({"path": None}))
+                
+        except Exception as e:
+            # Reset flag on error
+            SelectFolderHandler._dialog_open = False
+            self.set_status(400)
+            self.finish(json.dumps({
+                "error": str(e)
+            }))
+
+class FileScanHandler(APIHandler):
+    """Handler for scanning directories for files"""
+    
+    @tornado.web.authenticated
+    async def post(self):
+        try:
+            data = json.loads(self.request.body.decode('utf-8'))
+            paths = data.get('paths', [])
+            
+            if not paths:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "error": "No paths provided"
+                }))
+                return
+            
+            file_scanner = get_file_scanner_service()
+            # Pass the current working directory as the workspace root for relative path calculation
+            result = await file_scanner.scan_directories(paths, workspace_root=os.getcwd())
+            
+            # Update scanned directories tracking
+            scanned_dirs = file_scanner.get_scanned_directories()
+            current_dirs = scanned_dirs.get('directories', [])
+            
+            # Update directory metadata
+            for new_dir in result['scanned_directories']:
+                # Check if directory already exists
+                existing_dir = None
+                for existing in current_dirs:
+                    if existing['path'] == new_dir['path']:
+                        existing_dir = existing
+                        break
+                
+                if existing_dir:
+                    # Update existing directory
+                    existing_dir['file_count'] = new_dir['file_count']
+                    existing_dir['scanned_at'] = new_dir['scanned_at']
+                else:
+                    # Add new directory
+                    current_dirs.append(new_dir)
+            
+            # Save updated directories list
+            file_scanner.update_scanned_directories(current_dirs)
+            
+            self.finish(json.dumps(result))
+            
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": str(e)
+            }))
+
+
+class ScannedDirectoriesHandler(APIHandler):
+    """Handler for getting scanned directories list"""
+    
+    @tornado.web.authenticated
+    def get(self):
+        try:
+            file_scanner = get_file_scanner_service()
+            result = file_scanner.get_scanned_directories()
+            
+            self.finish(json.dumps(result))
+            
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": str(e)
+            }))
+
+
+class WorkDirHandler(APIHandler):
+    """Handler for returning current working directory"""
+
+    @tornado.web.authenticated
+    def get(self):
+        try:
+            self.finish(json.dumps({"workdir": os.getcwd()}))
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": str(e)
+            }))
+
+
+class DeleteScannedDirectoryHandler(APIHandler):
+    """Handler for deleting a scanned directory"""
+    
+    @tornado.web.authenticated
+    def post(self):
+        try:
+            data = json.loads(self.request.body.decode('utf-8'))
+            directory_path = data.get('path')
+            
+            if not directory_path:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "error": "No directory path provided"
+                }))
+                return
+            
+            file_scanner = get_file_scanner_service()
+            
+            # Get current scanned directories
+            current_directories = file_scanner.get_scanned_directories()
+            directories = current_directories.get('directories', [])
+            
+            # Filter out the directory to be deleted
+            filtered_directories = [
+                dir_info for dir_info in directories 
+                if dir_info.get('path') != directory_path
+            ]
+            
+            # Check if directory was actually found and removed
+            if len(filtered_directories) == len(directories):
+                self.set_status(404)
+                self.finish(json.dumps({
+                    "error": f"Directory '{directory_path}' not found in scanned directories"
+                }))
+                return
+            
+            # Update the scanned directories list
+            success = file_scanner.update_scanned_directories(filtered_directories)
+            
+            if success:
+                self.finish(json.dumps({
+                    "success": True,
+                    "message": f"Directory '{directory_path}' removed from scanning"
+                }))
+            else:
+                self.set_status(500)
+                self.finish(json.dumps({
+                    "error": "Failed to update scanned directories"
+                }))
+            
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": str(e)
+            }))
+
 def setup_handlers(web_app):
     host_pattern = ".*$"
     base_url = web_app.settings["base_url"]
@@ -268,6 +516,13 @@ def setup_handlers(web_app):
     # Read all files endpoint
     read_all_files_route = url_path_join(base_url, "signalpilot-ai-internal", "read-all-files")
     
+    # File scanning endpoints
+    file_scan_route = url_path_join(base_url, "signalpilot-ai-internal", "files", "scan")
+    scanned_directories_route = url_path_join(base_url, "signalpilot-ai-internal", "files", "directories")
+    select_folder_route = url_path_join(base_url, "signalpilot-ai-internal", "files", "select-folder")
+    workdir_route = url_path_join(base_url, "signalpilot-ai-internal", "files", "workdir")
+    delete_scanned_directory_route = url_path_join(base_url, "signalpilot-ai-internal", "files", "directories", "delete")
+
     # Cache service endpoints
     chat_histories_route = url_path_join(base_url, "signalpilot-ai-internal", "cache", "chat-histories")
     chat_history_route = url_path_join(base_url, "signalpilot-ai-internal", "cache", "chat-histories", "([^/]+)")
@@ -297,6 +552,13 @@ def setup_handlers(web_app):
         # Read all files endpoint
         (read_all_files_route, ReadAllFilesHandler),
         
+        # File scanning endpoints
+        (file_scan_route, FileScanHandler),
+        (scanned_directories_route, ScannedDirectoriesHandler),
+        (select_folder_route, SelectFolderHandler),
+        (workdir_route, WorkDirHandler),
+        (delete_scanned_directory_route, DeleteScannedDirectoryHandler),
+        
         # Chat histories endpoints
         (chat_histories_route, ChatHistoriesHandler),
         (chat_history_route, ChatHistoriesHandler),

{signalpilot_ai_internal-0.5.1.data → signalpilot_ai_internal-0.6.0.data}/data/share/jupyter/labextensions/signalpilot-ai-internal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalpilot-ai-internal",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "SignalPilot Agent - Your Jupyter Notebook Assistant",
   "keywords": [
     "jupyter",
@@ -134,7 +134,7 @@
     "outputDir": "signalpilot_ai_internal/labextension",
     "schemaDir": "schema",
     "_build": {
-      "load": "static/remoteEntry.59ffb91489066223094b.js",
+      "load": "static/remoteEntry.410a42566793b732952f.js",
       "extension": "./extension",
       "style": "./style"
     }

{signalpilot_ai_internal-0.5.1.data → signalpilot_ai_internal-0.6.0.data}/data/share/jupyter/labextensions/signalpilot-ai-internal/schemas/signalpilot-ai-internal/package.json.orig

@@ -1,6 +1,6 @@
 {
   "name": "signalpilot-ai-internal",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "SignalPilot Agent - Your Jupyter Notebook Assistant",
   "keywords": [
     "jupyter",