Add restart indexing feature to WebUI and Kotlin plugin, clean up verbose logs

Co-authored-by: Mte90 <403283+Mte90@users.noreply.github.com>

Author: Copilot

ai/analyzer.py

@@ -86,10 +86,9 @@ def _get_embedding_with_semaphore(semaphore: threading.Semaphore, text: str, fil
     semaphore.acquire()
     try:
         _thread_state.stage = "calling_embed_text"
-        logger.debug(f"Worker thread starting embed_text for {file_path} chunk {chunk_index}")
+        # Removed verbose debug logs for each chunk embedding
         result = _embedding_client.embed_text(text, file_path=file_path, chunk_index=chunk_index)
         _thread_state.stage = "completed"
-        logger.debug(f"Worker thread completed embed_text for {file_path} chunk {chunk_index}")
         return result
     except Exception as e:
         _thread_state.stage = f"exception: {type(e).__name__}"
@@ -158,14 +157,10 @@ def _process_file_sync(
 
         # Check if file needs reindexing (incremental mode)
         if incremental and not needs_reindex(database_path, rel_path, mtime, file_hash):
-            logger.debug(f"Skipping unchanged file: {rel_path}")
+            # Removed verbose debug log for skipped files
             return {"stored": False, "embedded": False, "skipped": True}
 
-        # Log file processing with progress
-        if file_num > 0 and total_files > 0:
-            logger.info(f"Processing file ({file_num}/{total_files}): {rel_path}")
-        else:
-            logger.info(f"Processing file: {rel_path}")
+        # Removed per-file processing log to reduce verbosity - progress is logged periodically
 
         # store file (synchronous DB writer) with metadata
         try:
@@ -282,25 +277,16 @@ def _process_file_sync(
                         embedded_any = True
                     except Exception as e:
                         failed_count += 1
-                        try:
-                            err_content = f"Failed to insert chunk vector: {e}\n\nTraceback:\n{traceback.format_exc()}"
-                            print(err_content)
-                        except Exception:
-                            logger.exception("Failed to write chunk-insert error to disk for %s chunk %d", rel_path, idx)
+                        # Log error instead of printing to reduce clutter
+                        logger.error(f"Failed to insert chunk vector for {rel_path} chunk {idx}: {e}")
                 else:
-                    logger.debug(f"Skipping chunk {idx} for {rel_path} - no embedding vector available")
+                    # Removed verbose debug log for skipping chunks
+                    pass
 
         return {"stored": True, "embedded": embedded_any, "skipped": False}
     except Exception:
-        tb = traceback.format_exc()
-        try:
-            error_payload = {"file": rel_path, "error": "processing error", "traceback": tb[:2000]}
-            try:
-                print(error_payload)
-            except Exception:
-                logger.exception("Failed to write exception error to disk for file %s", rel_path)
-        except Exception:
-            logger.exception("Failed while handling exception for file %s", rel_path)
+        # Log error instead of printing to reduce clutter
+        logger.exception("Failed to process file %s", rel_path)
         return {"stored": False, "embedded": False, "skipped": False}
 
 
@@ -441,13 +427,11 @@ def analyze_local_path_sync(
                 "meta",
             )
         except Exception:
-            try:
-                print("Failed to store uv_detected.json in DB")
-            except Exception:
-                logger.exception("Failed to write uv_detected meta error")
+            # Ignore failure to store non-critical metadata
+            pass
 
     except Exception:
-        traceback.print_exc()
+        logger.exception("Analysis failed for %s", local_path)
 
 
 def analyze_local_path_background(local_path: str, database_path: str, venv_path: Optional[str] = None, max_file_size: int = 200000, cfg: Optional[dict] = None):

ide-plugins/src/main/kotlin/com/picocode/PicoCodeToolWindowContent.kt

@@ -48,12 +48,21 @@ class PicoCodeToolWindowContent(private val project: Project) {
     fun getContent(): JComponent {
         val panel = JPanel(BorderLayout())
 
-        // Server config panel (collapsed by default)
+        // Server config panel with re-index button
         val configPanel = FormBuilder.createFormBuilder()
             .addLabeledComponent("PicoCode Host:", serverHostField)
             .addLabeledComponent("PicoCode Port:", serverPortField)
             .panel
 
+        // Add a re-index button to config panel
+        val reindexBtn = JButton("Re-index Project")
+        reindexBtn.addActionListener {
+            reindexProject()
+        }
+        val configPanelWithButton = JPanel(BorderLayout())
+        configPanelWithButton.add(configPanel, BorderLayout.CENTER)
+        configPanelWithButton.add(reindexBtn, BorderLayout.SOUTH)
+        
         // Chat display area
         val chatScrollPane = JBScrollPane(chatArea)
         chatScrollPane.border = BorderFactory.createTitledBorder("Chat")
@@ -90,7 +99,7 @@ class PicoCodeToolWindowContent(private val project: Project) {
         inputPanel.add(buttonPanel, BorderLayout.SOUTH)
 
         // Layout
-        panel.add(configPanel, BorderLayout.NORTH)
+        panel.add(configPanelWithButton, BorderLayout.NORTH)
         panel.add(chatScrollPane, BorderLayout.CENTER)
         panel.add(inputPanel, BorderLayout.SOUTH)
 
@@ -184,6 +193,59 @@ class PicoCodeToolWindowContent(private val project: Project) {
         }
     }
 
+    /**
+     * Re-index the current project
+     */
+    private fun reindexProject() {
+        val projectPath = project.basePath ?: return
+        val host = getServerHost()
+        val port = getServerPort()
+        
+        ApplicationManager.getApplication().executeOnPooledThread {
+            try {
+                // Get or create project to get project ID
+                val projectsUrl = URL("http://$host:$port/api/projects")
+                val createConnection = projectsUrl.openConnection() as HttpURLConnection
+                createConnection.requestMethod = "POST"
+                createConnection.setRequestProperty("Content-Type", "application/json")
+                createConnection.doOutput = true
+                
+                val createBody = gson.toJson(mapOf(
+                    "path" to projectPath,
+                    "name" to project.name
+                ))
+                createConnection.outputStream.use { it.write(createBody.toByteArray()) }
+                
+                val createResponse = createConnection.inputStream.bufferedReader().readText()
+                val projectData = gson.fromJson(createResponse, JsonObject::class.java)
+                val projectId = projectData.get("id").asString
+                
+                // Trigger re-indexing
+                val indexUrl = URL("http://$host:$port/api/projects/index")
+                val indexConnection = indexUrl.openConnection() as HttpURLConnection
+                indexConnection.requestMethod = "POST"
+                indexConnection.setRequestProperty("Content-Type", "application/json")
+                indexConnection.doOutput = true
+                
+                val indexBody = gson.toJson(mapOf("project_id" to projectId))
+                indexConnection.outputStream.use { it.write(indexBody.toByteArray()) }
+                
+                val indexResponse = indexConnection.inputStream.bufferedReader().readText()
+                val indexData = gson.fromJson(indexResponse, JsonObject::class.java)
+                
+                SwingUtilities.invokeLater {
+                    val status = indexData.get("status")?.asString ?: "unknown"
+                    appendToChat("System", "Re-indexing started. Status: $status")
+                }
+            } catch (e: Exception) {
+                SwingUtilities.invokeLater {
+                    appendToChat("Error", "Failed to start re-indexing: ${e.message}\n" +
+                        "Make sure PicoCode server is running on http://$host:$port")
+                }
+            }
+        }
+    }
+    
     /**
      * Clear chat history
      */

templates/index.html

@@ -69,7 +69,8 @@ <h5 class="card-title">Projects</h5>
                         Files: <span class="file-count">0</span> | Embeddings: <span class="embedding-count">0</span>
                       </small>
                     </div>
-                    <div>
+                    <div class="d-flex gap-1">
+                      <button type="button" class="btn btn-sm btn-outline-primary reindex-project-btn" data-project-id="{{ p.id }}" title="Re-index project">⟳</button>
                       <button type="button" class="btn btn-sm btn-outline-danger delete-project-btn" data-project-id="{{ p.id }}" title="Delete project">×</button>
                     </div>
                   </li>
@@ -311,8 +312,37 @@ <h5 class="card-title">Chat</h5>
       }
     }, 10000); // Poll every 10 seconds to reduce server load
 
-    // Handle project deletion
+    // Handle project re-indexing
     document.addEventListener('click', async (e) => {
+      if (e.target.classList.contains('reindex-project-btn')) {
+        const projectId = e.target.getAttribute('data-project-id');
+        
+        if (!confirm('Re-index this project? This will refresh all embeddings.')) {
+          return;
+        }
+        
+        try {
+          const response = await fetch('/api/projects/index', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ project_id: projectId })
+          });
+          
+          if (response.ok) {
+            const data = await response.json();
+            alert(`Re-indexing started. Status: ${data.status}`);
+            // Reload page to show updated status
+            window.location.reload();
+          } else {
+            const data = await response.json();
+            alert(`Failed to start re-indexing: ${data.error || 'Unknown error'}`);
+          }
+        } catch (err) {
+          alert(`Error starting re-indexing: ${err.message}`);
+        }
+      }
+      
+      // Handle project deletion
       if (e.target.classList.contains('delete-project-btn')) {
         const projectId = e.target.getAttribute('data-project-id');