ai-coding-assistant 0.5.0__py3-none-any.whl

coding_assistant/cli/commands/refactor.py

@@ -0,0 +1,245 @@
+"""Refactor command - Refactor code with validation and preview."""
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from pathlib import Path
+from typing import Optional
+
+from coding_assistant.config.settings import settings
+from coding_assistant.context.enhanced_retriever import EnhancedSemanticRetriever
+from coding_assistant.operations.generator import CodeGenerator
+from coding_assistant.operations.validator import SyntaxValidator
+from coding_assistant.operations.linter import LinterIntegration
+from coding_assistant.operations.differ import DiffGenerator
+from coding_assistant.llm.client import LLMClientFactory
+
+console = Console()
+
+
+def refactor_command(
+    target: str = typer.Argument(..., help="File path or file::function to refactor"),
+    strategy: str = typer.Option(
+        "improve readability and efficiency",
+        "--strategy",
+        "-s",
+        help="Refactoring strategy"
+    ),
+    auto_apply: bool = typer.Option(
+        False,
+        "--auto-apply",
+        "-y",
+        help="Apply changes without confirmation"
+    ),
+    run_linter: bool = typer.Option(
+        True,
+        "--lint/--no-lint",
+        help="Run linter on refactored code"
+    ),
+):
+    """Refactor code with AI assistance, validation, and preview.
+
+    The refactoring process:
+    1. Read original code
+    2. Get LLM refactoring suggestion
+    3. Extract and validate refactored code
+    4. Run linter (optional)
+    5. Show diff preview
+    6. Ask for confirmation (unless --auto-apply)
+    7. Apply changes
+
+    Examples:
+      assistant refactor src/utils.py
+      assistant refactor src/auth.py --strategy "extract helper functions"
+      assistant refactor src/module.py::process_data --auto-apply
+    """
+
+    console.print("\n🔧 [bold cyan]Code Refactoring[/bold cyan]\n")
+
+    # Parse target
+    if '::' in target:
+        file_path_str, function_name = target.split('::', 1)
+    else:
+        file_path_str = target
+        function_name = None
+
+    file_path = Path(file_path_str)
+
+    # Check file exists
+    if not file_path.exists():
+        console.print(f"[red]✗ File not found: {file_path}[/red]")
+        raise typer.Exit(1)
+
+    # Detect language
+    language_map = {
+        '.py': 'python',
+        '.js': 'javascript',
+        '.ts': 'typescript',
+        '.jsx': 'jsx',
+        '.tsx': 'tsx'
+    }
+    language = language_map.get(file_path.suffix, 'python')
+
+    # Read original code
+    try:
+        original_code = file_path.read_text(encoding='utf-8')
+    except Exception as e:
+        console.print(f"[red]✗ Error reading file: {e}[/red]")
+        raise typer.Exit(1)
+
+    # If function specified, extract it
+    target_code = original_code
+    if function_name:
+        # TODO: Extract specific function
+        console.print(f"[dim]Targeting function: {function_name}[/dim]")
+
+    # Show original code preview
+    console.print("[bold]Original Code:[/bold]")
+    console.print(Panel(
+        Syntax(original_code[:300] + ("..." if len(original_code) > 300 else ""),
+               language, theme="monokai", line_numbers=True),
+        title=str(file_path),
+        border_style="dim"
+    ))
+    console.print()
+
+    # Get context for better refactoring
+    context_chunks = []
+    try:
+        retriever = EnhancedSemanticRetriever(settings.project_path)
+        stats = retriever.get_stats()
+
+        if stats['total_chunks'] > 0:
+            with console.status("[bold green]Finding related code for context..."):
+                results = retriever.retrieve(
+                    query=f"code related to {file_path.name}",
+                    k=3,
+                    current_file=str(file_path),
+                    language=language
+                )
+                context_chunks = results
+    except:
+        pass
+
+    # Build refactoring prompt
+    with console.status("[bold green]Generating refactoring suggestions..."):
+        llm = LLMClientFactory.create_client(settings.llm_provider)
+
+        system_prompt = f"""You are an expert code refactoring assistant.
+
+Your task: Refactor the provided {language} code according to the strategy: "{strategy}"
+
+Guidelines:
+- Preserve functionality (same inputs → same outputs)
+- Improve code quality, readability, and efficiency
+- Follow {language} best practices
+- Add helpful comments where appropriate
+- Return ONLY the refactored code in a code block
+- Do not include explanations outside the code block
+
+Strategy: {strategy}"""
+
+        user_prompt = f"""Refactor this {language} code:
+
+```{language}
+{target_code}
+```
+"""
+
+        if context_chunks:
+            user_prompt += "\n\nRelated code for context:\n"
+            for chunk in context_chunks[:2]:
+                user_prompt += f"\n```{chunk.get('language', language)}\n{chunk['content'][:200]}...\n```\n"
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+
+        # Get refactored code
+        try:
+            response = ""
+            for chunk in llm.generate(messages, stream=False):
+                response += chunk
+        except Exception as e:
+            console.print(f"[red]✗ Error generating refactoring: {e}[/red]")
+            raise typer.Exit(1)
+
+    # Extract code blocks
+    console.print("[bold green]✓[/bold green] Refactoring generated\n")
+
+    generator = CodeGenerator()
+    blocks = generator.extract_code_blocks(response, validate=True)
+
+    if not blocks:
+        console.print("[red]✗ No code found in refactoring response[/red]")
+        console.print("[dim]Response was:[/dim]")
+        console.print(response[:500])
+        raise typer.Exit(1)
+
+    refactored_code = blocks[0].code
+
+    # Validate syntax
+    console.print("[bold]Validating refactored code...[/bold]")
+    validator = SyntaxValidator()
+    validation_result = validator.validate(refactored_code, language)
+
+    if not validation_result.is_valid:
+        console.print(f"[red]✗ Refactored code has syntax errors:[/red]")
+        console.print(f"[red]  Line {validation_result.line}: {validation_result.error_message}[/red]")
+        console.print("\n[yellow]Refactoring failed. Original code unchanged.[/yellow]\n")
+        raise typer.Exit(1)
+
+    console.print("[green]✓ Syntax valid[/green]\n")
+
+    # Run linter if requested
+    if run_linter:
+        console.print("[bold]Running linter...[/bold]")
+        linter = LinterIntegration(project_root=str(settings.project_path))
+        lint_result = linter.lint(refactored_code, language, auto_fix=True)
+
+        if lint_result.error_count > 0:
+            console.print(f"[yellow]⚠️  Found {lint_result.error_count} linting issues[/yellow]")
+            linter.display_issues(lint_result)
+
+            if lint_result.fixed_code:
+                console.print("[green]✓ Auto-fixed linting issues[/green]")
+                refactored_code = lint_result.fixed_code
+        else:
+            console.print("[green]✓ No linting issues[/green]")
+        console.print()
+
+    # Generate and show diff
+    console.print("[bold]Changes Preview:[/bold]\n")
+    differ = DiffGenerator()
+    diff = differ.generate_diff(original_code, refactored_code, str(file_path))
+    differ.display_diff(diff, title=f"Refactoring: {file_path}")
+
+    stats = differ.get_change_stats(diff)
+    console.print(f"\n[bold]Change Summary:[/bold]")
+    console.print(f"  Lines added: [green]{stats['lines_added']}[/green]")
+    console.print(f"  Lines removed: [red]{stats['lines_removed']}[/red]")
+    console.print(f"  Net change: {stats['net_change']:+d}")
+    console.print()
+
+    # Ask for confirmation
+    if not auto_apply:
+        if not typer.confirm("Apply these changes?"):
+            console.print("[yellow]Refactoring cancelled. No changes made.[/yellow]\n")
+            raise typer.Exit(0)
+
+    # Apply changes
+    try:
+        file_path.write_text(refactored_code, encoding='utf-8')
+        console.print(f"\n[bold green]✓ Refactoring applied to {file_path}[/bold green]\n")
+
+        # Show next steps
+        console.print("[dim]Next steps:")
+        console.print(f"  • Review: git diff {file_path}")
+        console.print(f"  • Test: Run your tests")
+        console.print(f"  • Commit: git commit -m 'Refactor {file_path.name}'[/dim]\n")
+
+    except Exception as e:
+        console.print(f"[red]✗ Error writing file: {e}[/red]")
+        raise typer.Exit(1)

coding_assistant/cli/commands/search.py

@@ -0,0 +1,182 @@
+"""Search command - Search codebase with hybrid search."""
+
+import typer
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.panel import Panel
+from pathlib import Path
+from typing import Optional
+
+from coding_assistant.config.settings import settings
+from coding_assistant.context.enhanced_retriever import EnhancedSemanticRetriever
+
+console = Console()
+
+
+def search_command(
+    query: str = typer.Argument(..., help="Search query (natural language)"),
+    limit: int = typer.Option(
+        5,
+        "--limit",
+        "-l",
+        help="Number of results to return"
+    ),
+    file_type: Optional[str] = typer.Option(
+        None,
+        "--type",
+        "-t",
+        help="Filter by file type (e.g., python, javascript)"
+    ),
+    directory: Optional[str] = typer.Option(
+        None,
+        "--dir",
+        "-d",
+        help="Filter by directory"
+    ),
+    show_content: bool = typer.Option(
+        True,
+        "--content/--no-content",
+        help="Show code content in results"
+    ),
+):
+    """Search your codebase with hybrid semantic + keyword search.
+
+    Examples:
+      assistant search "authentication implementation"
+      assistant search "JWT validation" --type python
+      assistant search "database queries" --dir src/db --limit 10
+    """
+
+    console.print("\n🔍 [bold cyan]Searching Codebase[/bold cyan]\n")
+    console.print(f"Query: [bold]{query}[/bold]\n")
+
+    # Initialize retriever
+    try:
+        retriever = EnhancedSemanticRetriever(settings.project_path)
+    except Exception as e:
+        console.print(f"[red]✗ Error initializing retriever: {e}[/red]")
+        raise typer.Exit(1)
+
+    # Check if indexed
+    stats = retriever.get_stats()
+    if stats['total_chunks'] == 0:
+        console.print("[yellow]⚠️  Codebase not indexed.[/yellow]")
+        console.print("[yellow]   Run 'assistant index' first to enable search.[/yellow]\n")
+        raise typer.Exit(1)
+
+    # Show search stats
+    if settings.verbose:
+        console.print(f"[dim]Index stats:[/dim]")
+        console.print(f"[dim]  • Total chunks: {stats['total_chunks']}[/dim]")
+        console.print(f"[dim]  • Hybrid search: {stats['hybrid_search_enabled']}[/dim]")
+        console.print()
+
+    # Perform search
+    try:
+        with console.status("[bold green]Searching..."):
+            results = retriever.retrieve(
+                query=query,
+                k=limit * 2,  # Get more, then filter
+                language=file_type,
+                use_hybrid=True,
+                use_ranking=True
+            )
+
+            # Apply filters
+            if directory:
+                dir_path = Path(directory)
+                results = [r for r in results if str(dir_path) in r['path']]
+
+            if file_type:
+                results = [r for r in results if r.get('language') == file_type]
+
+            # Limit results
+            results = results[:limit]
+
+    except Exception as e:
+        console.print(f"[red]✗ Search error: {e}[/red]")
+        if settings.verbose:
+            import traceback
+            traceback.print_exc()
+        raise typer.Exit(1)
+
+    # Display results
+    if not results:
+        console.print("[yellow]No results found.[/yellow]\n")
+        console.print("[dim]Try:")
+        console.print("  • Broadening your search query")
+        console.print("  • Removing filters")
+        console.print("  • Re-indexing with 'assistant index --force'[/dim]\n")
+        return
+
+    console.print(f"[bold green]✓ Found {len(results)} results[/bold green]\n")
+
+    # Create results table
+    table = Table(
+        title=f"Search Results for: '{query}'",
+        show_header=True,
+        header_style="bold magenta",
+        border_style="blue",
+        show_lines=True
+    )
+
+    table.add_column("#", width=3, style="dim")
+    table.add_column("File", style="cyan")
+    table.add_column("Type", width=10)
+    table.add_column("Name", style="bold")
+    table.add_column("Score", width=8, justify="right")
+    table.add_column("Lines", width=10, justify="center")
+
+    for i, result in enumerate(results, 1):
+        # Determine score color
+        score = result.get('rank_score', result.get('similarity', 0.0))
+        if score > 0.8:
+            score_style = "bold green"
+        elif score > 0.6:
+            score_style = "yellow"
+        else:
+            score_style = "dim"
+
+        table.add_row(
+            str(i),
+            result['path'],
+            result.get('type', 'file'),
+            result.get('name', '-'),
+            f"[{score_style}]{score:.2f}[/{score_style}]",
+            f"{result.get('start_line', 0)}-{result.get('end_line', 0)}"
+        )
+
+    console.print(table)
+    console.print()
+
+    # Show detailed content if requested
+    if show_content:
+        for i, result in enumerate(results[:3], 1):  # Show top 3 in detail
+            console.print(f"[bold]Result {i}: {result['path']}[/bold]")
+
+            # Show code with syntax highlighting
+            code = result.get('content', '')
+            if code:
+                lang = result.get('language', 'text')
+                syntax = Syntax(
+                    code[:300] + ("..." if len(code) > 300 else ""),
+                    lang if lang in ('python', 'javascript', 'typescript') else 'text',
+                    theme="monokai",
+                    line_numbers=True,
+                    start_line=result.get('start_line', 1)
+                )
+                console.print(Panel(syntax, border_style="dim"))
+            console.print()
+
+        if len(results) > 3:
+            console.print(f"[dim]... and {len(results) - 3} more results[/dim]")
+            console.print(f"[dim]Use --no-content to see all results in table only[/dim]\n")
+
+    # Show search tips
+    console.print("[dim]💡 Search Tips:[/dim]")
+    console.print("[dim]  • Use natural language: 'how to authenticate users'[/dim]")
+    console.print("[dim]  • Or keywords: 'JWT token validation'[/dim]")
+    console.print("[dim]  • Filter by type: --type python[/dim]")
+    console.print("[dim]  • Filter by directory: --dir src/auth[/dim]")
+    console.print("[dim]  • Increase results: --limit 20[/dim]\n")

coding_assistant/cli/commands/serve_docs.py

@@ -0,0 +1,128 @@
+"""Documentation server command.
+
+This module provides a simple HTTP server for viewing generated
+documentation locally.
+"""
+
+from pathlib import Path
+import http.server
+import socketserver
+import webbrowser
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+# Create Typer app
+serve_docs_app = typer.Typer(
+    name="serve-docs",
+    help="Serve documentation locally with HTTP server",
+    no_args_is_help=True
+)
+
+
+@serve_docs_app.command()
+def serve_command(
+    docs_dir: Path = typer.Option(
+        "./docs/generated",
+        "--dir",
+        "-d",
+        help="Documentation directory to serve"
+    ),
+    port: int = typer.Option(
+        8000,
+        "--port",
+        "-p",
+        help="Server port"
+    ),
+    open_browser: bool = typer.Option(
+        True,
+        "--open/--no-open",
+        help="Open browser automatically"
+    ),
+):
+    """
+    Serve documentation locally via HTTP.
+
+    This command starts a simple HTTP server to view the generated
+    documentation in a web browser. Markdown files will be served
+    as plain text (for rendering, use a static site generator).
+
+    Examples:
+        assistant serve-docs
+        assistant serve-docs --port 3000
+        assistant serve-docs --dir ./my-docs --no-open
+    """
+    if not docs_dir.exists():
+        console.print(f"[red]Error:[/red] Documentation directory not found: {docs_dir}")
+        console.print(f"[dim]Run:[/dim] [cyan]assistant document generate[/cyan] first")
+        raise typer.Exit(1)
+
+    # Change to docs directory
+    import os
+    original_dir = os.getcwd()
+    os.chdir(docs_dir)
+
+    try:
+        # Create HTTP server
+        handler = http.server.SimpleHTTPRequestHandler
+
+        # Custom handler to add basic routing
+        class DocHandler(handler):
+            def do_GET(self):
+                # Redirect root to README.md
+                if self.path == '/':
+                    self.path = '/README.md'
+                return super().do_GET()
+
+            def log_message(self, format, *args):
+                # Custom logging to console
+                console.print(f"[dim]{args[0]}[/dim] - {args[1]} - {args[2]}")
+
+        with socketserver.TCPServer(("", port), DocHandler) as httpd:
+            url = f"http://localhost:{port}"
+
+            console.print(Panel.fit(
+                f"[bold cyan]Documentation Server Running[/bold cyan]\\n"
+                f"URL: {url}\\n"
+                f"Directory: {docs_dir.resolve()}",
+                border_style="cyan"
+            ))
+
+            console.print("")
+            console.print("[green]✓[/green] Server started successfully")
+            console.print(f"[cyan]→[/cyan] Visit {url} in your browser")
+            console.print("")
+            console.print("[dim]Press Ctrl+C to stop the server[/dim]")
+            console.print("")
+
+            # Open browser if requested
+            if open_browser:
+                try:
+                    webbrowser.open(url)
+                    console.print("[green]✓[/green] Browser opened")
+                except Exception:
+                    pass
+
+            # Serve forever
+            httpd.serve_forever()
+
+    except KeyboardInterrupt:
+        console.print("\\n\\n[yellow]Server stopped[/yellow]")
+
+    except OSError as e:
+        if "Address already in use" in str(e):
+            console.print(f"[red]Error:[/red] Port {port} is already in use")
+            console.print(f"[dim]Try a different port:[/dim] [cyan]--port {port + 1}[/cyan]")
+        else:
+            console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    finally:
+        # Change back to original directory
+        os.chdir(original_dir)
+
+
+# Export the Typer app
+__all__ = ['serve_docs_app']