feat: Add comprehensive project deletion cleanup across all systems

- Enhanced delete_project endpoint to perform complete cleanup:
  * Disconnects all WebSocket connections
  * Stops and removes agent process managers
  * Stops dev servers
  * Deletes database files (features.db, assistant.db)
  * Unregisters from registry
  * Optionally deletes entire project directory

- Added cleanup_manager function in process_manager to remove specific project managers
- Added disconnect_all_for_project method in ConnectionManager
- Updated ImportProjectModal to detect project name conflicts
- Added Delete Existing Project button with confirmation dialog
- Fixed 'deleteProject assigned but never used' error

This ensures projects are cleanly removed from registry, websockets, API,
database, agents, and dev servers, preventing conflicts when reimporting.

Author: Agent-Planner

server/routers/projects.py

@@ -331,11 +331,18 @@ async def get_project(name: str):
 @router.delete("/{name}")
 async def delete_project(name: str, delete_files: bool = False):
     """
-    Delete a project from the registry.
+    Delete a project from the registry and perform comprehensive cleanup.
+
+    This removes the project from:
+    - Registry (project registration)
+    - Database (features.db file)
+    - WebSocket connections (all active connections)
+    - Agent processes (stop and cleanup)
+    - Dev servers (stop if running)
 
     Args:
         name: Project name to delete
-        delete_files: If True, also delete the project directory and files
+        delete_files: If True, also delete the project directory and all files
     """
     _init_imports()
     _, unregister_project, get_project_path, _, _ = _get_registry_functions()
@@ -354,19 +361,63 @@ async def delete_project(name: str, delete_files: bool = False):
             detail="Cannot delete project while agent is running. Stop the agent first."
         )
 
-    # Optionally delete files
+    # Step 1: Disconnect all WebSocket connections for this project
+    from .websocket import manager as websocket_manager
+    try:
+        disconnected = await websocket_manager.disconnect_all_for_project(name)
+        logger.info(f"Disconnected {disconnected} WebSocket connection(s) for project '{name}'")
+    except Exception as e:
+        logger.warning(f"Error disconnecting WebSocket connections for project '{name}': {e}")
+
+    # Step 2: Stop agent process manager for this project
+    from .services.process_manager import cleanup_manager as cleanup_process_manager
+    from .services.dev_server_manager import get_devserver_manager
+    try:
+        await cleanup_process_manager(name, project_dir)
+        logger.info(f"Stopped agent process manager for project '{name}'")
+    except Exception as e:
+        logger.warning(f"Error stopping agent process manager for project '{name}': {e}")
+
+    # Step 3: Stop dev server if running for this project
+    try:
+        devserver_mgr = get_devserver_manager()
+        await devserver_mgr.stop_server(name)
+        logger.info(f"Stopped dev server for project '{name}'")
+    except Exception as e:
+        logger.warning(f"Error stopping dev server for project '{name}': {e}")
+
+    # Step 4: Delete database files (features.db, assistant.db)
+    db_files = ["features.db", "assistant.db"]
+    deleted_dbs = []
+    for db_file in db_files:
+        db_path = project_dir / db_file
+        if db_path.exists():
+            try:
+                db_path.unlink()
+                deleted_dbs.append(db_file)
+                logger.info(f"Deleted {db_file} for project '{name}'")
+            except Exception as e:
+                logger.warning(f"Error deleting {db_file} for project '{name}': {e}")
+
+    # Step 5: Optionally delete the entire project directory
     if delete_files and project_dir.exists():
         try:
             shutil.rmtree(project_dir)
+            logger.info(f"Deleted project directory for '{name}'")
         except Exception as e:
             raise HTTPException(status_code=500, detail=f"Failed to delete project files: {e}")
 
-    # Unregister from registry
+    # Step 6: Unregister from registry (do this last)
     unregister_project(name)
+    logger.info(f"Unregistered project '{name}' from registry")
 
     return {
         "success": True,
-        "message": f"Project '{name}' deleted" + (" (files removed)" if delete_files else " (files preserved)")
+        "message": f"Project '{name}' deleted completely" + (" (including files)" if delete_files else " (files preserved)"),
+        "details": {
+            "databases_deleted": deleted_dbs,
+            "files_deleted": delete_files
+        }
     }
 
 

server/services/process_manager.py

@@ -633,6 +633,27 @@ async def cleanup_all_managers() -> None:
         _managers.clear()
 
 
+async def cleanup_manager(project_name: str, project_dir: Path) -> None:
+    """Stop and remove a specific project's agent process manager.
+    
+    Args:
+        project_name: Name of the project
+        project_dir: Absolute path to the project directory
+    """
+    with _managers_lock:
+        # Use composite key to match get_manager
+        key = (project_name, str(project_dir.resolve()))
+        manager = _managers.pop(key, None)
+    
+    if manager:
+        try:
+            if manager.status != "stopped":
+                await manager.stop()
+            logger.info(f"Cleaned up agent process manager for project: {project_name}")
+        except Exception as e:
+            logger.warning(f"Error stopping manager for {project_name}: {e}")
+
+
 def cleanup_orphaned_locks() -> int:
     """
     Clean up orphaned lock files from previous server runs.

server/websocket.py

@@ -618,6 +618,31 @@ def get_connection_count(self, project_name: str) -> int:
         """Get number of active connections for a project."""
         return len(self.active_connections.get(project_name, set()))
 
+    async def disconnect_all_for_project(self, project_name: str) -> int:
+        """Disconnect all WebSocket connections for a specific project.
+        
+        Args:
+            project_name: Name of the project
+            
+        Returns:
+            Number of connections that were disconnected
+        """
+        async with self._lock:
+            connections = list(self.active_connections.get(project_name, set()))
+            if project_name in self.active_connections:
+                del self.active_connections[project_name]
+        
+        # Close connections outside the lock to avoid deadlock
+        closed_count = 0
+        for connection in connections:
+            try:
+                await connection.close(code=1000, reason="Project deleted")
+                closed_count += 1
+            except Exception as e:
+                logger.warning(f"Error closing WebSocket connection for project {project_name}: {e}")
+        
+        return closed_count
+
 
 # Global connection manager
 manager = ConnectionManager()

ui/src/components/ImportProjectModal.tsx

@@ -28,10 +28,12 @@ import {
   Square,
   ChevronDown,
   ChevronRight,
+  Trash2,
 } from 'lucide-react'
 import { useImportProject } from '../hooks/useImportProject'
-import { useCreateProject, useDeleteProject } from '../hooks/useProjects'
+import { useCreateProject, useDeleteProject, useProjects } from '../hooks/useProjects'
 import { FolderBrowser } from './FolderBrowser'
+import { ConfirmDialog } from './ConfirmDialog'
 
 type Step = 'folder' | 'analyzing' | 'detected' | 'features' | 'register' | 'complete'
 
@@ -50,6 +52,11 @@ export function ImportProjectModal({
   const [projectName, setProjectName] = useState('')
   const [expandedCategories, setExpandedCategories] = useState<Set<string>>(new Set())
   const [registerError, setRegisterError] = useState<string | null>(null)
+  const [showDeleteConfirm, setShowDeleteConfirm] = useState(false)
+  const [projectToDelete, setProjectToDelete] = useState<string | null>(null)
+
+  // Fetch existing projects to check for conflicts
+  const { data: existingProjects } = useProjects()
 
   const {
     state,
@@ -150,6 +157,27 @@ export function ImportProjectModal({
     onClose()
   }
 
+  const handleDeleteExistingProject = async () => {
+    if (!projectToDelete) return
+
+
+    try {
+      await deleteProject.mutateAsync(projectToDelete)
+      setShowDeleteConfirm(false)
+      setProjectToDelete(null)
+      
+      // Refresh the import step to reflect the deletion
+      if (step === 'register') {
+        // Stay on register step so user can now create the project with same name
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to delete project'
+      setRegisterError(`Delete failed: ${errorMessage}`)
+      setShowDeleteConfirm(false)
+      setProjectToDelete(null)
+    }
+  }
+
   const handleBack = () => {
     if (step === 'detected') {
       setStep('folder')
@@ -529,6 +557,11 @@ export function ImportProjectModal({
 
   // Register project step
   if (step === 'register') {
+    // Check if project name already exists
+    const existingProject = existingProjects?.find(p => p.name === projectName)
+    const nameConflict = !!existingProject
+
+
     return (
       <div className="neo-modal-backdrop" onClick={handleClose}>
         <div
@@ -557,10 +590,41 @@ export function ImportProjectModal({
                 className="neo-input"
                 pattern="^[a-zA-Z0-9_-]+$"
                 autoFocus
+                disabled={createProject.isPending}
               />
               <p className="text-sm text-[var(--color-neo-text-secondary)] mt-2">
                 Use letters, numbers, hyphens, and underscores only.
               </p>
+              {nameConflict && (
+                <div className="mt-3 p-3 bg-[var(--color-neo-error-bg)] border-3 border-[var(--color-neo-error-border)] rounded">
+                  <p className="text-sm text-[var(--color-neo-error-text)] font-bold mb-1">
+                    Project name already exists!
+                  </p>
+                  <p className="text-xs text-[var(--color-neo-error-text)] mb-2">
+                    A project named "{projectName}" is already registered.
+                  </p>
+                  <button
+                    onClick={() => {
+                      setProjectToDelete(projectName)
+                      setShowDeleteConfirm(true)
+                    }}
+                    className="neo-btn neo-btn-destructive text-sm"
+                    disabled={deleteProject.isPending}
+                  >
+                    {deleteProject.isPending ? (
+                      <>
+                        <Loader2 size={14} className="animate-spin mr-1" />
+                        Deleting...
+                      </>
+                    ) : (
+                      <>
+                        <Trash2 size={14} className="mr-1" />
+                        Delete Existing Project
+                      </>
+                    )}
+                  </button>
+                </div>
+              )}
             </div>
 
             <div className="mb-6 p-4 bg-[var(--color-neo-bg-secondary)] border-3 border-[var(--color-neo-border)]">
@@ -648,5 +712,32 @@ export function ImportProjectModal({
     )
   }
 
+  // Delete confirmation dialog
+  if (showDeleteConfirm) {
+    return (
+      <ConfirmDialog
+        isOpen={showDeleteConfirm}
+        title="Delete Existing Project"
+        message={`Are you sure you want to delete "${projectToDelete}"? This will:
+
+• Remove the project from the registry
+• Disconnect all WebSocket connections
+• Stop any running agent processes
+• Delete all database files (features.db, assistant.db)
+• Stop any dev servers
+• Preserve the project files on disk`}
+        confirmLabel="Delete Project"
+        cancelLabel="Cancel"
+        variant="danger"
+        isLoading={deleteProject.isPending}
+        onConfirm={handleDeleteExistingProject}
+        onCancel={() => {
+          setShowDeleteConfirm(false)
+          setProjectToDelete(null)
+        }}
+      />
+    )
+  }
+
   return null
 }