feat(cli): rebuild/reset commands

Author: Daniele Briggi

src/sqlite_rag/cli.py

@@ -114,15 +114,53 @@ def remove(
 
 
 @app.command()
-def rebuild():
+def rebuild(
+    remove_missing: bool = typer.Option(
+        False, "--remove-missing", help="Remove documents whose files are not found"
+    )
+):
     """Rebuild embeddings and full-text index"""
-    pass
+    rag = SQLiteRag()
+
+    typer.echo("Starting rebuild process...")
+
+    result = rag.rebuild(remove_missing=remove_missing)
+
+    typer.echo(f"Rebuild completed:")
+    typer.echo(f"  Total documents: {result['total']}")
+    typer.echo(f"  Reprocessed: {result['reprocessed']}")
+    typer.echo(f"  Not found: {result['not_found']}")
+    typer.echo(f"  Removed: {result['removed']}")
 
 
 @app.command()
-def reset():
+def reset(
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt")
+):
     """Reset/clear the entire database"""
-    pass
+    rag = SQLiteRag()
+
+    # Show warning and ask for confirmation unless -y flag is used
+    if not yes:
+        typer.echo(
+            "WARNING: This will permanently delete all documents and data from the database!"
+        )
+        typer.echo(f"Database file: {rag.settings.db_path}")
+        typer.echo()
+        confirm = typer.confirm("Are you sure you want to reset the entire database?")
+        if not confirm:
+            typer.echo("Reset cancelled.")
+            return
+
+    typer.echo("Resetting database...")
+
+    success = rag.reset()
+
+    if success:
+        typer.echo("Database reset completed successfully.")
+    else:
+        typer.echo("Failed to reset database.")
+        raise typer.Exit(1)
 
 
 @app.command()
@@ -138,7 +176,14 @@ def search(
         return
 
     typer.echo(f"Found {len(results)} documents:")
-    
+    # print the position, the snippet and the uri as a table
+    typer.echo(f"{'Position':<10} {'Content':<50}")
+    typer.echo("-" * 60)
+    for i, doc in enumerate(results, start=1):
+        uri_or_content = doc.uri or (
+            doc.content[:47] + "..." if len(doc.content) > 47 else doc.content
+        )
+        typer.echo(f"{i:<10} {uri_or_content:<50}")
 
 
 def repl_mode():
@@ -147,7 +192,7 @@ def repl_mode():
 
     while True:
         try:
-            command = input("sqlite-rag> ").strip()
+            command = input("\nsqlite-rag> ").strip()
             if not command:
                 continue
 

src/sqlite_rag/sqliterag.py

@@ -102,9 +102,96 @@ def remove_document(self, identifier: str) -> bool:
 
         return self._repository.remove_document(document.id or "")
 
-    def search(
-        self, query: str, top_k: int = 10
-    ) -> list[Document]:
+    def rebuild(self, remove_missing: bool = False) -> dict:
+        """Rebuild embeddings and full-text index for all documents"""
+        self._ensure_initialized()
+
+        documents = self._repository.list_documents()
+        total_docs = len(documents)
+        reprocessed = 0
+        not_found = 0
+        removed = 0
+
+        for doc in documents:
+            if doc.uri and Path(doc.uri).exists():
+                # File still exists, recreate embeddings
+                try:
+                    content = FileReader.parse_file(Path(doc.uri))
+                    doc.content = content
+
+                    self._repository.remove_document(doc.id or "")
+                    processed_doc = self._engine.process(doc)
+                    self._repository.add_document(processed_doc)
+
+                    reprocessed += 1
+                    self._logger.debug(f"Reprocessed: {doc.uri}")
+                except Exception as e:
+                    self._logger.error(f"Error processing {doc.uri}: {e}")
+                    not_found += 1
+            elif doc.uri:
+                # File not found
+                not_found += 1
+                self._logger.warning(f"File not found: {doc.uri}")
+
+                if remove_missing:
+                    self._repository.remove_document(doc.id or "")
+                    removed += 1
+                    self._logger.info(f"Removed missing document: {doc.uri}")
+            else:
+                # Document without URI (text content)
+                try:
+                    self._repository.remove_document(doc.id or "")
+                    processed_doc = self._engine.process(doc)
+                    self._repository.add_document(processed_doc)
+
+                    reprocessed += 1
+                    self._logger.debug(f"Reprocessed text document: {doc.content[:20]!r}...")
+                except Exception as e:
+                    self._logger.error(f"Error processing text document {doc.id}: {e}")
+
+        if self.settings.quantize_scan:
+            self._engine.quantize()
+
+        return {
+            "total": total_docs,
+            "reprocessed": reprocessed,
+            "not_found": not_found,
+            "removed": removed,
+        }
+
+    def reset(self) -> bool:
+        """Reset/clear the entire database by deleting and recreating it"""
+        db_path = self.settings.db_path
+        
+        try:
+            # Close the database connection
+            self._conn.close()
+            
+            # Delete the database file if it exists
+            if Path(db_path).exists():
+                Path(db_path).unlink()
+                self._logger.info(f"Deleted database file: {db_path}")
+            
+            # Recreate the database connection and initialize
+            self._conn = sqlite3.connect(db_path)
+            Database.initialize(self._conn, self.settings)
+            
+            # Reinitialize components with new connection
+            self._repository = Repository(self._conn, self.settings)
+            self._chunker = Chunker(self._conn, self.settings)
+            self._engine = Engine(self._conn, self.settings, chunker=self._chunker)
+            
+            # Reset ready flag so initialization happens on next use
+            self.ready = False
+            
+            self._logger.info("Database reset completed successfully")
+            return True
+            
+        except Exception as e:
+            self._logger.error(f"Error during database reset: {e}")
+            return False
+
+    def search(self, query: str, top_k: int = 10) -> list[Document]:
         """Search for documents matching the query"""
         self._ensure_initialized()