codemate-cli 1.0.0__py3-none-any.whl

codemate/commands/kb_commands.py

@@ -0,0 +1,749 @@
+# codemate/commands/kb_commands.py
+"""Knowledge Base Management Commands"""
+
+import os
+import uuid
+import json
+import time
+import platform
+import socketio
+import httpx
+from pathlib import Path
+from typing import Optional, List, Tuple, Set
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+from rich.table import Table
+from rich import box
+
+console = Console()
+
+
+class KBCommands:
+    """Handler for Knowledge Base operations"""
+    
+    def __init__(self, config, client):
+        self.config = config
+        self.client = client
+        self.socket_url = "http://localhost:45224"
+        self.api_url = "http://localhost:45223"
+    
+    def _normalize_path(self, path_str: str) -> Path:
+        """Normalize path for cross-platform compatibility"""
+        path_str = os.path.expanduser(path_str)
+        path = Path(path_str).resolve()
+        return path
+    
+    def _validate_path(self, path: Path) -> Tuple[bool, Optional[str]]:
+        """
+        Validate if path exists and is accessible
+        
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not path.exists():
+            return False, f"Path does not exist: {path}"
+        
+        if not path.is_dir():
+            return False, f"Path is not a directory: {path}"
+        
+        if not os.access(path, os.R_OK):
+            return False, f"No read permission for: {path}"
+        
+        try:
+            if not any(path.iterdir()):
+                return False, f"Directory is empty: {path}"
+        except PermissionError:
+            return False, f"Cannot access directory contents: {path}"
+        
+        return True, None
+    
+    def _parse_gitignore_patterns(self, gitignore_path: Path) -> Set[str]:
+        """Parse .gitignore file and return set of patterns"""
+        patterns = set()
+        
+        try:
+            with open(gitignore_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        patterns.add(line)
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not read .gitignore: {e}[/yellow]")
+        
+        return patterns
+
+    def _should_exclude(self, path: Path, exclude_patterns: Set[str], base_path: Path) -> bool:
+        """Check if path matches any exclude pattern"""
+        relative_path = path.relative_to(base_path)
+        path_str = str(relative_path).replace('\\', '/')
+        
+        for pattern in exclude_patterns:
+            if pattern.endswith('/'):
+                if path.is_dir() and (path_str + '/').startswith(pattern):
+                    return True
+                if path_str.startswith(pattern.rstrip('/')):
+                    return True
+            elif '*' in pattern:
+                import fnmatch
+                if fnmatch.fnmatch(path_str, pattern):
+                    return True
+                if fnmatch.fnmatch(path.name, pattern):
+                    return True
+            else:
+                if path_str == pattern or path.name == pattern:
+                    return True
+                if pattern in path_str.split('/'):
+                    return True
+        
+        return False
+
+    def _collect_files(
+        self, 
+        base_path: Path, 
+        progress_callback=None
+    ) -> List[str]:
+        """
+        Recursively collect all files from directory, excluding patterns
+        
+        Returns:
+            List of absolute file paths as strings
+        """
+        files = []
+        total_scanned = 0
+        
+        default_excludes = {
+            '.git/', '__pycache__/', 'node_modules/', '.venv/', 'venv/',
+            '.env', '.pyc', '.DS_Store', 'Thumbs.db', '.idea/', '.vscode/'
+        }
+        
+        for root, dirs, filenames in os.walk(base_path):
+            root_path = Path(root)
+            
+            dirs[:] = [
+                d for d in dirs 
+                if not self._should_exclude(root_path / d, default_excludes, base_path)
+            ]
+            
+            for filename in filenames:
+                file_path = root_path / filename
+                total_scanned += 1
+                
+                if self._should_exclude(file_path, default_excludes, base_path):
+                    continue
+                
+                try:
+                    if file_path.stat().st_size > 10_000_000:
+                        continue
+                except:
+                    continue
+                
+                files.append(str(file_path))
+                
+                if progress_callback and total_scanned % 100 == 0:
+                    progress_callback(len(files), total_scanned)
+        
+        return files
+    
+    def _validate_url(self, url: str) -> bool:
+        """Validate if URL has proper format"""
+        url = url.strip()
+        if not url:
+            return False
+        return url.startswith(('http://', 'https://'))
+    
+    async def create_kb(self) -> bool:
+        """Interactive knowledge base creation flow"""
+        console.print()
+        console.print(Panel(
+            "[cyan]📚 Create Knowledge Base[/cyan]\n\n"
+            "[white]Choose the type of knowledge base you want to create.[/white]",
+            border_style="cyan",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        console.print()
+        
+        # Step 0: Choose KB type
+        console.print("[bold cyan]Step 1:[/bold cyan] Select knowledge base type")
+        console.print()
+        
+        type_table = Table(
+            show_header=True,
+            header_style="bold magenta",
+            border_style="blue",
+            box=box.ROUNDED
+        )
+        type_table.add_column("#", style="dim", width=4)
+        type_table.add_column("Type", style="cyan", width=15)
+        type_table.add_column("Description", style="white", width=50)
+        
+        type_table.add_row("1", "codebase", "Index a local directory/project with code files")
+        type_table.add_row("2", "docs", "Index documentation from URL(s)")
+        
+        console.print(type_table)
+        console.print()
+        
+        kb_type_input = Prompt.ask(
+            "[cyan]Select type[/cyan]",
+            choices=["1", "2", "codebase", "docs"],
+            default="1"
+        )
+        
+        # Normalize input
+        if kb_type_input in ["1", "codebase"]:
+            kb_type = "codebase"
+            return await self._create_codebase_kb()
+        else:
+            kb_type = "docs"
+            return await self._create_docs_kb()
+    
+    async def _create_codebase_kb(self) -> bool:
+        """Create a codebase knowledge base from local directory"""
+        console.print()
+        console.print("[dim]═" * console.width + "[/dim]")
+        console.print()
+        
+        # Step 1: Get directory path
+        console.print("[bold cyan]Step 2:[/bold cyan] Specify the directory path")
+        console.print("[dim]Enter the full path to the directory you want to index[/dim]")
+        console.print()
+        
+        path_input = Prompt.ask(
+            "[cyan]Directory path[/cyan]",
+            default="."
+        )
+        
+        # Normalize and validate path
+        try:
+            kb_path = self._normalize_path(path_input)
+            is_valid, error_msg = self._validate_path(kb_path)
+            
+            if not is_valid:
+                console.print()
+                console.print(Panel(
+                    f"[red]❌ Invalid Path[/red]\n\n{error_msg}",
+                    border_style="red",
+                    padding=(1, 2)
+                ))
+                return False
+            
+            console.print(f"[green]✓[/green] Valid path: [cyan]{kb_path}[/cyan]")
+            console.print()
+            
+        except Exception as e:
+            console.print()
+            console.print(Panel(
+                f"[red]❌ Error validating path[/red]\n\n{str(e)}",
+                border_style="red",
+                padding=(1, 2)
+            ))
+            return False
+        
+        # Step 2: Get KB name
+        default_name = kb_path.name
+        console.print("[bold cyan]Step 3:[/bold cyan] Name your knowledge base")
+        console.print(f"[dim]Default: {default_name}[/dim]")
+        console.print()
+        
+        kb_name = Prompt.ask(
+            "[cyan]Knowledge base name[/cyan]",
+            default=default_name
+        )
+        console.print()
+        
+        # Step 3: Get description
+        console.print("[bold cyan]Step 4:[/bold cyan] Add a description [dim](optional)[/dim]")
+        kb_description = Prompt.ask(
+            "[cyan]Description[/cyan]",
+            default=""
+        )
+        console.print()
+        console.print("[dim]─" * console.width + "[/dim]")
+        console.print()
+        
+        # Show summary
+        summary = Table(
+            show_header=False,
+            border_style="cyan",
+            box=box.ROUNDED,
+            padding=(0, 1)
+        )
+        summary.add_column(style="cyan bold", width=20)
+        summary.add_column(style="white")
+        
+        summary.add_row("Type:", "codebase")
+        summary.add_row("Path:", str(kb_path))
+        summary.add_row("Name:", kb_name)
+        summary.add_row("Description:", kb_description or "[dim](none)[/dim]")
+        
+        console.print(Panel(
+            summary,
+            title="[bold cyan]📋 Summary[/bold cyan]",
+            border_style="cyan",
+            padding=(1, 2)
+        ))
+        console.print()
+        
+        # Confirm creation
+        if not Confirm.ask("[cyan]Create this knowledge base?[/cyan]", default=True):
+            console.print("[yellow]Cancelled.[/yellow]")
+            return False
+        
+        console.print()
+        console.print("[dim]─" * console.width + "[/dim]")
+        console.print()
+        
+        # Collect files
+        console.print("[cyan]🔍 Scanning directory...[/cyan]")
+        console.print()
+        
+        files = []
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                transient=True
+            ) as progress:
+                task = progress.add_task("Scanning files...", total=None)
+                
+                def progress_callback(found, scanned):
+                    progress.update(task, description=f"Found {found} files (scanned {scanned})")
+                
+                files = self._collect_files(kb_path, progress_callback)
+            
+            if not files:
+                console.print()
+                console.print(Panel(
+                    "[yellow]⚠️ No files found[/yellow]\n\n"
+                    "The directory appears to be empty or all files were excluded.",
+                    border_style="yellow",
+                    padding=(1, 2)
+                ))
+                return False
+            
+            console.print(f"[green]✓[/green] Found [cyan]{len(files)}[/cyan] files")
+            console.print()
+            
+        except Exception as e:
+            console.print()
+            console.print(Panel(
+                f"[red]❌ Error scanning directory[/red]\n\n{str(e)}",
+                border_style="red",
+                padding=(1, 2)
+            ))
+            return False
+        
+        # Prepare upload data
+        kb_id = str(uuid.uuid4())
+        request_id = ''.join(str(uuid.uuid4()).split('-'))[:22]
+        
+        upload_data = {
+            "id": kb_id,
+            "isAutoIndexed": False,
+            "name": kb_name,
+            "description": kb_description,
+            "source": "LOCAL",
+            "scope": "personal",
+            "syncConfig": {
+                "enabled": False,
+                "lastSynced": int(time.time() * 1000)
+            },
+            "status": "draft",
+            "progress": {
+                "status": "",
+                "message": "",
+                "progress": 0
+            },
+            "dateCreated": int(time.time() * 1000),
+            "dateSynced": None,
+            "dateUpdated": None,
+            "can_sync": False,
+            "can_upload": False,
+            "cloud_id": "",
+            "type": "codebase",
+            "metadata": {
+                "path": str(kb_path),
+                "files": files
+            },
+            "request_id": request_id
+        }
+        
+        # Upload
+        console.print("[cyan]📤 Uploading to server...[/cyan]")
+        console.print()
+        
+        try:
+            await self._upload_via_socket(upload_data, "codebase")
+            return True
+        except Exception as e:
+            console.print()
+            console.print(Panel(
+                f"[red]❌ Upload failed[/red]\n\n{str(e)}",
+                border_style="red",
+                padding=(1, 2)
+            ))
+            return False
+    
+    async def _create_docs_kb(self) -> bool:
+        """Create a docs knowledge base from URLs"""
+        console.print()
+        console.print("[dim]═" * console.width + "[/dim]")
+        console.print()
+        
+        # Step 1: Get URLs
+        console.print("[bold cyan]Step 2:[/bold cyan] Provide documentation URL(s)")
+        console.print("[dim]Enter one or more URLs (comma-separated)[/dim]")
+        console.print("[dim]Example: https://docs.example.com, https://guide.example.com[/dim]")
+        console.print()
+        
+        urls_input = Prompt.ask("[cyan]Documentation URL(s)[/cyan]")
+        
+        # Parse and validate URLs
+        urls = [url.strip() for url in urls_input.split(',')]
+        valid_urls = []
+        invalid_urls = []
+        
+        for url in urls:
+            if self._validate_url(url):
+                valid_urls.append(url)
+            else:
+                invalid_urls.append(url)
+        
+        if invalid_urls:
+            console.print()
+            console.print(Panel(
+                f"[yellow]⚠️ Invalid URL(s) found:[/yellow]\n\n" +
+                "\n".join([f"• {url}" for url in invalid_urls]) +
+                "\n\n[white]URLs must start with http:// or https://[/white]",
+                border_style="yellow",
+                padding=(1, 2)
+            ))
+        
+        if not valid_urls:
+            console.print()
+            console.print(Panel(
+                "[red]❌ No valid URLs provided[/red]",
+                border_style="red",
+                padding=(1, 2)
+            ))
+            return False
+        
+        console.print(f"[green]✓[/green] Valid URLs: [cyan]{len(valid_urls)}[/cyan]")
+        console.print()
+        
+        # Step 2: Get KB name
+        console.print("[bold cyan]Step 3:[/bold cyan] Name your knowledge base")
+        console.print()
+        
+        kb_name = Prompt.ask("[cyan]Knowledge base name[/cyan]")
+        console.print()
+        
+        # Step 3: Get description
+        console.print("[bold cyan]Step 4:[/bold cyan] Add a description [dim](optional)[/dim]")
+        kb_description = Prompt.ask(
+            "[cyan]Description[/cyan]",
+            default=""
+        )
+        console.print()
+        console.print("[dim]─" * console.width + "[/dim]")
+        console.print()
+        
+        # Show summary
+        summary = Table(
+            show_header=False,
+            border_style="cyan",
+            box=box.ROUNDED,
+            padding=(0, 1)
+        )
+        summary.add_column(style="cyan bold", width=20)
+        summary.add_column(style="white")
+        
+        summary.add_row("Type:", "docs")
+        summary.add_row("URLs:", str(len(valid_urls)))
+        summary.add_row("Name:", kb_name)
+        summary.add_row("Description:", kb_description or "[dim](none)[/dim]")
+        
+        console.print(Panel(
+            summary,
+            title="[bold cyan]📋 Summary[/bold cyan]",
+            border_style="cyan",
+            padding=(1, 2)
+        ))
+        console.print()
+        
+        # Show URLs
+        if valid_urls:
+            console.print("[cyan]URLs to index:[/cyan]")
+            for i, url in enumerate(valid_urls, 1):
+                console.print(f"  [dim]{i}.[/dim] {url}")
+            console.print()
+        
+        # Confirm creation
+        if not Confirm.ask("[cyan]Create this knowledge base?[/cyan]", default=True):
+            console.print("[yellow]Cancelled.[/yellow]")
+            return False
+        
+        console.print()
+        console.print("[dim]─" * console.width + "[/dim]")
+        console.print()
+        
+        # Prepare upload data
+        kb_id = str(uuid.uuid4())
+        request_id = ''.join(str(uuid.uuid4()).split('-'))[:22]
+        
+        upload_data = {
+            "id": kb_id,
+            "isAutoIndexed": False,
+            "name": kb_name,
+            "description": kb_description,
+            "source": "DOCS",
+            "scope": "personal",
+            "syncConfig": {
+                "enabled": False,
+                "lastSynced": int(time.time() * 1000)
+            },
+            "status": "draft",
+            "progress": {
+                "status": "",
+                "message": "",
+                "progress": 0
+            },
+            "dateCreated": int(time.time() * 1000),
+            "dateSynced": None,
+            "dateUpdated": None,
+            "can_sync": False,
+            "can_upload": False,
+            "cloud_id": "",
+            "type": "docs",
+            "metadata": {
+                "urls": valid_urls
+            },
+            "request_id": request_id
+        }
+        
+        # Upload
+        console.print("[cyan]📤 Processing documentation...[/cyan]")
+        console.print()
+        
+        try:
+            await self._upload_via_socket(upload_data, "docs")
+            return True
+        except Exception as e:
+            console.print()
+            console.print(Panel(
+                f"[red]❌ Processing failed[/red]\n\n{str(e)}",
+                border_style="red",
+                padding=(1, 2)
+            ))
+            return False
+    
+    async def _upload_via_socket(self, upload_data: dict, kb_type: str):
+        """Upload knowledge base via SocketIO"""
+        sio = socketio.AsyncClient()
+        upload_complete = False
+        upload_error = None
+        
+        @sio.on("upload:success")
+        def on_success(data):
+            nonlocal upload_complete
+            upload_complete = True
+            console.print()
+            
+            if kb_type == "codebase":
+                file_count = len(upload_data['metadata']['files'])
+                detail_line = f"[white]Files:[/white] [cyan]{file_count}[/cyan]"
+            else:
+                url_count = len(upload_data['metadata']['urls'])
+                detail_line = f"[white]URLs:[/white] [cyan]{url_count}[/cyan]"
+            
+            console.print(Panel(
+                "[green]✓ Knowledge base created successfully![/green]\n\n"
+                f"[white]Name:[/white] [cyan]{upload_data['name']}[/cyan]\n"
+                f"{detail_line}\n\n"
+                "[dim]Use /listkb to view all knowledge bases[/dim]",
+                border_style="green",
+                title="[bold green]Success[/bold green]",
+                padding=(1, 2)
+            ))
+        
+        @sio.on("upload:error")
+        def on_error(data):
+            nonlocal upload_complete, upload_error
+            upload_complete = True
+            upload_error = data.get("message", "Unknown error")
+            console.print()
+            console.print(Panel(
+                f"[red]❌ Upload failed[/red]\n\n{upload_error}",
+                border_style="red",
+                padding=(1, 2)
+            ))
+        
+        try:
+            # Connect to server
+            await sio.connect(self.socket_url)
+            
+            # Send upload event
+            await sio.emit("upload", upload_data)
+            
+            # Wait for completion with progress indicator
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                transient=True
+            ) as progress:
+                task = progress.add_task(
+                    f"Processing {kb_type}..." if kb_type == "docs" else "Uploading files...",
+                    total=None
+                )
+                
+                timeout = 6000  # 5 minutes
+                start_time = time.time()
+                
+                while not upload_complete:
+                    if time.time() - start_time > timeout:
+                        raise TimeoutError("Upload timed out after 5 minutes")
+                    await sio.sleep(0.5)
+            
+            if upload_error:
+                raise Exception(upload_error)
+            
+        finally:
+            await sio.disconnect()
+    
+    async def delete_kb(self) -> bool:
+        """Interactive knowledge base deletion"""
+        console.print()
+        console.print(Panel(
+            "[red]🗑️  Delete Knowledge Base[/red]\n\n"
+            "[yellow]Warning: This action cannot be undone![/yellow]",
+            border_style="red",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        console.print()
+        
+        # Get available KBs
+        try:
+            kbs = self.client.list_kbs()
+            
+            if not kbs:
+                console.print("[yellow]No knowledge bases found.[/yellow]")
+                return False
+            
+            # Show available KBs
+            console.print("[cyan]Available knowledge bases:[/cyan]")
+            console.print()
+            
+            table = Table(
+                show_header=True,
+                header_style="bold magenta",
+                border_style="blue",
+                box=box.ROUNDED
+            )
+            table.add_column("#", style="dim", width=4)
+            table.add_column("Name", style="cyan", width=25)
+            table.add_column("Type", style="yellow", width=12)
+            table.add_column("Files/Items", style="green", width=12)
+            
+            for idx, kb in enumerate(kbs, 1):
+                kb_name = kb.get('name', '')
+                kb_type = kb.get('type', 'unknown')
+                
+                # Get count based on type
+                metadata = kb.get('metadata', {})
+                if kb_type == "codebase":
+                    count = len(metadata.get('files', [])) if 'files' in metadata else '-'
+                elif kb_type == "docs":
+                    count = len(metadata.get('urls', [])) if 'urls' in metadata else '-'
+                else:
+                    count = '-'
+                
+                table.add_row(str(idx), kb_name, kb_type, str(count))
+            
+            console.print(table)
+            console.print()
+            
+        except Exception as e:
+            console.print(f"[red]Error listing knowledge bases: {e}[/red]")
+            return False
+        
+        # Get KB to delete
+        kb_input = Prompt.ask(
+            "[cyan]Enter knowledge base name or number[/cyan]"
+        )
+        
+        # Find KB
+        selected_kb = None
+        
+        try:
+            idx = int(kb_input) - 1
+            if 0 <= idx < len(kbs):
+                selected_kb = kbs[idx]
+        except ValueError:
+            for kb in kbs:
+                if kb.get('name', '').lower() == kb_input.lower():
+                    selected_kb = kb
+                    break
+        
+        if not selected_kb:
+            console.print()
+            console.print(f"[red]❌ Knowledge base not found: {kb_input}[/red]")
+            return False
+        
+        kb_name = selected_kb.get('name')
+        kb_id = selected_kb.get('id')
+        
+        console.print()
+        console.print(f"[yellow]⚠️  You are about to delete:[/yellow] [cyan]{kb_name}[/cyan]")
+        console.print()
+        
+        # Confirm deletion
+        if not Confirm.ask(
+            f"[red]Are you sure you want to delete '{kb_name}'?[/red]",
+            default=False
+        ):
+            console.print("[yellow]Cancelled.[/yellow]")
+            return False
+        
+        # Delete KB
+        console.print()
+        console.print("[cyan]🗑️  Deleting knowledge base...[/cyan]")
+        
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(
+                    f"{self.api_url}/delete_kb",
+                    json={"kbid": kb_id},
+                    headers={"Content-Type": "application/json"}
+                )
+                response.raise_for_status()
+                result = response.json()
+                
+                if result.get("status") == "success":
+                    console.print()
+                    console.print(Panel(
+                        f"[green]✓ Successfully deleted '{kb_name}'[/green]",
+                        border_style="green",
+                        padding=(1, 2)
+                    ))
+                    return True
+                else:
+                    error_msg = result.get("message", "Unknown error")
+                    console.print()
+                    console.print(Panel(
+                        f"[red]❌ Deletion failed[/red]\n\n{error_msg}",
+                        border_style="red",
+                        padding=(1, 2)
+                    ))
+                    return False
+                
+        except Exception as e:
+            console.print()
+            console.print(Panel(
+                f"[red]❌ Error deleting knowledge base[/red]\n\n{str(e)}",
+                border_style="red",
+                padding=(1, 2)
+            ))
+            return False