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

coding_assistant/cli/commands/explain.py

@@ -0,0 +1,192 @@
+"""Explain command - Explain how code works with enhanced context."""
+
+import typer
+from rich.console import Console
+from rich.syntax import Syntax
+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
+from coding_assistant.llm.client import LLMClientFactory
+from coding_assistant.llm.prompts import PromptBuilder
+from coding_assistant.codebase.parser import CodeParser
+
+console = Console()
+
+
+def explain_command(
+    target: str = typer.Argument(..., help="File path or file::function to explain"),
+    context_size: int = typer.Option(
+        5,
+        "--context",
+        "-c",
+        help="Number of related code chunks to include"
+    ),
+    detailed: bool = typer.Option(
+        False,
+        "--detailed",
+        "-d",
+        help="Provide detailed explanation with examples"
+    ),
+):
+    """Explain how code works with intelligent context.
+
+    Examples:
+      assistant explain src/auth/login.py
+      assistant explain src/auth/login.py::authenticate_user
+      assistant explain src/utils.py --detailed
+    """
+
+    console.print("\n🔍 [bold cyan]Code Explanation[/bold cyan]\n")
+
+    # Parse target (file or file::function)
+    if '::' in target:
+        file_path, function_name = target.split('::', 1)
+    else:
+        file_path = target
+        function_name = None
+
+    file_path = Path(file_path)
+
+    # Check if file exists
+    if not file_path.exists():
+        console.print(f"[red]✗ File not found: {file_path}[/red]")
+        raise typer.Exit(1)
+
+    # Read the code
+    try:
+        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, try to extract it
+    target_code = code
+    if function_name:
+        parser = CodeParser()
+        try:
+            parsed = parser.parse_file(str(file_path), code)
+
+            # Find the function
+            found = False
+            for chunk in parsed.get('chunks', []):
+                if chunk.get('name') == function_name:
+                    target_code = chunk['content']
+                    found = True
+                    console.print(f"[dim]Found function: {function_name}[/dim]\n")
+                    break
+
+            if not found:
+                console.print(f"[yellow]⚠️  Function '{function_name}' not found, explaining entire file[/yellow]\n")
+        except:
+            console.print(f"[yellow]⚠️  Could not parse file, explaining entire content[/yellow]\n")
+
+    # Show the code we're explaining
+    console.print(Panel(
+        Syntax(target_code[:500] + ("..." if len(target_code) > 500 else ""),
+               "python" if file_path.suffix == '.py' else "javascript",
+               theme="monokai",
+               line_numbers=True),
+        title=f"Code to Explain: {file_path.name}" + (f"::{function_name}" if function_name else ""),
+        border_style="blue"
+    ))
+
+    # Get relevant context using enhanced retrieval
+    context_chunks = []
+    try:
+        with console.status("[bold green]Finding relevant context..."):
+            retriever = EnhancedSemanticRetriever(settings.project_path)
+
+            # Check if indexed
+            stats = retriever.get_stats()
+            if stats['total_chunks'] > 0:
+                # Search for related code
+                query = f"code related to {file_path.name}" + (f" {function_name}" if function_name else "")
+
+                results = retriever.retrieve(
+                    query=query,
+                    k=context_size,
+                    current_file=str(file_path),
+                    language='python' if file_path.suffix == '.py' else 'javascript',
+                    use_hybrid=True,
+                    use_ranking=True
+                )
+
+                if settings.verbose and results:
+                    console.print("\n[dim]Related code found:[/dim]")
+                    for r in results:
+                        console.print(f"[dim]  • {r['path']} - {r['name']} (score: {r['rank_score']:.2f})[/dim]")
+                    console.print()
+
+                context_chunks = results
+            else:
+                console.print("[yellow]⚠️  Codebase not indexed. Run 'assistant index' for better context.[/yellow]\n")
+
+    except Exception as e:
+        if settings.verbose:
+            console.print(f"[yellow]⚠️  Could not retrieve context: {e}[/yellow]\n")
+
+    # Build explanation prompt
+    prompt_builder = PromptBuilder()
+
+    system_prompt = """You are an expert code reviewer and educator. Your task is to explain code clearly and thoroughly.
+
+When explaining code:
+1. Start with a high-level overview of what the code does
+2. Explain the main components and their purposes
+3. Highlight important logic and design decisions
+4. Point out any potential issues or improvements
+5. Use clear, concise language suitable for developers
+
+If the code uses specific patterns or frameworks, mention them."""
+
+    if detailed:
+        system_prompt += """
+
+Provide a detailed explanation including:
+- Step-by-step walkthrough of the logic
+- Example inputs and outputs
+- Edge cases handled
+- Dependencies and integrations
+- Best practices applied or missing"""
+
+    # Build context section
+    context_text = f"# Code to Explain\n\nFile: `{file_path}`\n"
+    if function_name:
+        context_text += f"Function: `{function_name}`\n"
+    context_text += f"\n```{file_path.suffix[1:] if file_path.suffix else 'text'}\n{target_code}\n```\n\n"
+
+    # Add related code context
+    if context_chunks:
+        context_text += "# Related Code (for context)\n\n"
+        for chunk in context_chunks[:3]:  # Limit to top 3
+            context_text += f"## {chunk['path']}\n"
+            context_text += f"```{chunk.get('language', 'text')}\n{chunk['content'][:300]}...\n```\n\n"
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": context_text + "\nPlease explain this code."}
+    ]
+
+    # Get LLM client
+    llm = LLMClientFactory.create_client(settings.llm_provider)
+
+    # Generate explanation
+    console.print("[bold blue]Explanation:[/bold blue]\n")
+
+    try:
+        response_text = ""
+        for chunk in llm.generate(messages, stream=True):
+            console.print(chunk, end="")
+            response_text += chunk
+        console.print("\n")
+
+        # Show helpful tips
+        if not detailed:
+            console.print("[dim]💡 Tip: Use --detailed for a more thorough explanation[/dim]")
+
+    except Exception as e:
+        console.print(f"\n[red]✗ Error generating explanation: {e}[/red]")
+        raise typer.Exit(1)

coding_assistant/cli/commands/fix.py

@@ -0,0 +1,249 @@
+"""Fix command - Fix linting issues and bugs."""
+
+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.operations.validator import SyntaxValidator
+from coding_assistant.operations.linter import LinterIntegration
+from coding_assistant.operations.generator import CodeGenerator
+from coding_assistant.operations.differ import DiffGenerator
+from coding_assistant.llm.client import LLMClientFactory
+
+console = Console()
+
+
+def fix_command(
+    file_path: str = typer.Argument(..., help="File path to fix"),
+    error: Optional[str] = typer.Option(
+        None,
+        "--error",
+        "-e",
+        help="Specific error message to fix"
+    ),
+    auto_apply: bool = typer.Option(
+        False,
+        "--auto-apply",
+        "-y",
+        help="Apply fixes without confirmation"
+    ),
+    lint_only: bool = typer.Option(
+        False,
+        "--lint-only",
+        help="Only fix linting issues (no AI fixes)"
+    ),
+):
+    """Fix linting issues and bugs in code.
+
+    The fix process:
+    1. Validate syntax
+    2. Run linter to find issues
+    3. Try auto-fix for linting issues
+    4. If error specified, get AI fix
+    5. Validate fixed code
+    6. Show diff
+    7. Apply with confirmation
+
+    Examples:
+      assistant fix src/module.py
+      assistant fix src/auth.py --error "TypeError: expected str, got int"
+      assistant fix src/utils.py --lint-only --auto-apply
+    """
+
+    console.print("\n🔧 [bold cyan]Fix Code Issues[/bold cyan]\n")
+
+    file_path_obj = Path(file_path)
+
+    # Check file exists
+    if not file_path_obj.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_obj.suffix, 'python')
+
+    # Read original code
+    try:
+        original_code = file_path_obj.read_text(encoding='utf-8')
+    except Exception as e:
+        console.print(f"[red]✗ Error reading file: {e}[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]File:[/bold] {file_path}")
+    console.print(f"[dim]Language: {language}[/dim]\n")
+
+    # Step 1: Validate syntax
+    console.print("[bold]1. Validating syntax...[/bold]")
+    validator = SyntaxValidator()
+    validation_result = validator.validate(original_code, language)
+
+    if not validation_result.is_valid:
+        console.print(f"[red]✗ Syntax error at line {validation_result.line}:[/red]")
+        console.print(f"[red]  {validation_result.error_message}[/red]\n")
+
+        if lint_only:
+            console.print("[yellow]Cannot auto-fix syntax errors with --lint-only.[/yellow]")
+            console.print("[yellow]Use without --lint-only to get AI-powered fix.[/yellow]\n")
+            raise typer.Exit(1)
+
+        # Will need AI fix
+        error = error or validation_result.error_message
+    else:
+        console.print("[green]✓ Syntax valid[/green]\n")
+
+    # Step 2: Run linter
+    console.print("[bold]2. Running linter...[/bold]")
+    linter = LinterIntegration(project_root=str(settings.project_path))
+    lint_result = linter.lint(original_code, language, auto_fix=True)
+
+    if lint_result.error_count == 0 and lint_result.warning_count == 0:
+        console.print("[green]✓ No linting issues found[/green]\n")
+
+        if not error:
+            console.print("[green]✓ Code is clean! No fixes needed.[/green]\n")
+            return
+    else:
+        console.print(f"[yellow]Found {lint_result.error_count} errors, {lint_result.warning_count} warnings[/yellow]")
+        linter.display_issues(lint_result)
+        console.print()
+
+    # Step 3: Apply auto-fixes
+    fixed_code = original_code
+
+    if lint_result.fixed_code:
+        console.print("[bold]3. Applying linter auto-fixes...[/bold]")
+        fixed_code = lint_result.fixed_code
+        console.print("[green]✓ Auto-fixed linting issues[/green]\n")
+
+        # If lint-only mode and we have fixes, show and apply
+        if lint_only:
+            differ = DiffGenerator()
+            diff = differ.generate_diff(original_code, fixed_code, file_path)
+            differ.display_diff(diff, title="Linting Fixes")
+
+            if not auto_apply:
+                if not typer.confirm("\nApply these fixes?"):
+                    console.print("[yellow]Cancelled.[/yellow]\n")
+                    raise typer.Exit(0)
+
+            file_path_obj.write_text(fixed_code, encoding='utf-8')
+            console.print(f"\n[green]✓ Fixes applied to {file_path}[/green]\n")
+            return
+
+    # Step 4: AI-powered fix (if error specified or syntax invalid)
+    if error and not lint_only:
+        console.print(f"[bold]4. Getting AI fix for error...[/bold]")
+        console.print(f"[dim]Error: {error}[/dim]\n")
+
+        llm = LLMClientFactory.create_client(settings.llm_provider)
+
+        system_prompt = f"""You are an expert {language} debugger and code fixer.
+
+Your task: Fix the code error while preserving functionality.
+
+Guidelines:
+- Fix ONLY the specific error mentioned
+- Preserve all other functionality
+- Follow {language} best practices
+- Add comments explaining the fix if needed
+- Return ONLY the fixed code in a code block
+- Do not include explanations outside the code block"""
+
+        user_prompt = f"""Fix this {language} code error:
+
+Error: {error}
+
+Code:
+```{language}
+{fixed_code}
+```
+
+Please provide the fixed code."""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+
+        # Get fix from LLM
+        with console.status("[bold green]Generating fix..."):
+            try:
+                response = ""
+                for chunk in llm.generate(messages, stream=False):
+                    response += chunk
+            except Exception as e:
+                console.print(f"[red]✗ Error generating fix: {e}[/red]")
+                raise typer.Exit(1)
+
+        # Extract fixed code
+        generator = CodeGenerator()
+        blocks = generator.extract_code_blocks(response, validate=True)
+
+        if not blocks:
+            console.print("[red]✗ No code found in fix response[/red]")
+            raise typer.Exit(1)
+
+        ai_fixed_code = blocks[0].code
+
+        # Validate AI fix
+        validation_result = validator.validate(ai_fixed_code, language)
+        if not validation_result.is_valid:
+            console.print(f"[red]✗ AI-generated fix has syntax errors:[/red]")
+            console.print(f"[red]  {validation_result.error_message}[/red]")
+            raise typer.Exit(1)
+
+        fixed_code = ai_fixed_code
+        console.print("[green]✓ AI fix generated and validated[/green]\n")
+
+    # Step 5: Show diff and apply
+    if fixed_code != original_code:
+        console.print("[bold]Changes Preview:[/bold]\n")
+        differ = DiffGenerator()
+        diff = differ.generate_diff(original_code, fixed_code, file_path)
+        differ.display_diff(diff, title=f"Fixes for {file_path_obj.name}")
+
+        stats = differ.get_change_stats(diff)
+        console.print(f"\n[dim]Lines changed: {stats['lines_added'] + stats['lines_removed']}[/dim]\n")
+
+        # Confirm
+        if not auto_apply:
+            if not typer.confirm("Apply these fixes?"):
+                console.print("[yellow]Cancelled. No changes made.[/yellow]\n")
+                raise typer.Exit(0)
+
+        # Apply
+        try:
+            file_path_obj.write_text(fixed_code, encoding='utf-8')
+            console.print(f"\n[bold green]✓ Fixes applied to {file_path}[/bold green]\n")
+
+            # Verify fix worked
+            console.print("[bold]Verifying fix...[/bold]")
+            final_validation = validator.validate(fixed_code, language)
+            final_lint = linter.lint(fixed_code, language, auto_fix=False)
+
+            if final_validation.is_valid:
+                console.print("[green]✓ Syntax valid[/green]")
+
+            if final_lint.error_count == 0:
+                console.print("[green]✓ No linting errors[/green]")
+            else:
+                console.print(f"[yellow]⚠️  Still has {final_lint.error_count} linting issues[/yellow]")
+
+            console.print()
+
+        except Exception as e:
+            console.print(f"[red]✗ Error writing file: {e}[/red]")
+            raise typer.Exit(1)
+    else:
+        console.print("[green]No changes needed![/green]\n")

coding_assistant/cli/commands/index.py

@@ -0,0 +1,162 @@
+"""Index command - Index codebase for semantic search."""
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from rich.table import Table
+
+from coding_assistant.config.settings import settings
+from coding_assistant.context.enhanced_retriever import EnhancedSemanticRetriever
+
+console = Console()
+
+
+def index_command(
+    max_files: int = typer.Option(
+        100,
+        "--max-files",
+        "-m",
+        help="Maximum number of files to index"
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force re-index (clear existing index)"
+    ),
+    stats: bool = typer.Option(
+        False,
+        "--stats",
+        "-s",
+        help="Show index statistics only (don't index)"
+    ),
+):
+    """Index your codebase for semantic search with smart chunking.
+
+    This command:
+    - Crawls your codebase
+    - Chunks code at function/class level
+    - Generates embeddings
+    - Builds vector + BM25 search index
+
+    Examples:
+      assistant index
+      assistant index --force --max-files 200
+      assistant index --stats
+    """
+
+    console.print("\n📚 [bold cyan]Codebase Indexing[/bold cyan]\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)
+
+    # If just showing stats
+    if stats:
+        try:
+            stats_data = retriever.get_stats()
+
+            # Create stats table
+            table = Table(title="Index Statistics", show_header=True, header_style="bold magenta")
+            table.add_column("Metric", style="cyan")
+            table.add_column("Value", justify="right", style="green")
+
+            table.add_row("Total Chunks", str(stats_data.get('total_chunks', 0)))
+            table.add_row("Indexed Chunks", str(stats_data.get('indexed_chunks', 0)))
+            table.add_row("Embedding Dimension", str(stats_data.get('embedding_dimension', 0)))
+            table.add_row("Hybrid Search", "✓" if stats_data.get('hybrid_search_enabled') else "✗")
+            table.add_row("Vector Store Size", str(stats_data.get('vector_store_count', 0)))
+
+            console.print(table)
+            console.print()
+
+            if stats_data.get('total_chunks', 0) == 0:
+                console.print("[yellow]⚠️  Codebase not indexed yet. Run 'assistant index' to index.[/yellow]\n")
+            else:
+                console.print(f"[green]✓ Index is ready for search![/green]\n")
+
+            return
+        except Exception as e:
+            console.print(f"[red]✗ Error getting stats: {e}[/red]")
+            raise typer.Exit(1)
+
+    # Clear if force flag
+    if force:
+        console.print("[yellow]Clearing existing index...[/yellow]")
+        try:
+            retriever.clear_index()
+            console.print("[green]✓ Index cleared[/green]\n")
+        except Exception as e:
+            console.print(f"[yellow]⚠️  Could not clear index: {e}[/yellow]\n")
+
+    # Check if already indexed (unless force)
+    if not force:
+        try:
+            stats_data = retriever.get_stats()
+            if stats_data.get('total_chunks', 0) > 0:
+                console.print(f"[yellow]⚠️  Codebase already indexed ({stats_data['total_chunks']} chunks).[/yellow]")
+                console.print("[yellow]   Use --force to re-index.[/yellow]\n")
+
+                if not typer.confirm("Continue anyway?"):
+                    console.print("[dim]Cancelled.[/dim]")
+                    raise typer.Exit(0)
+                console.print()
+        except:
+            pass
+
+    # Index with progress bar
+    console.print(f"[bold]Indexing up to {max_files} files...[/bold]")
+    console.print("[dim]This may take a minute for large codebases...[/dim]\n")
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+            transient=False
+        ) as progress:
+
+            task = progress.add_task("[cyan]Indexing codebase...", total=100)
+
+            # Index codebase
+            retriever.index_codebase(max_files=max_files, force_reindex=force)
+
+            progress.update(task, completed=100)
+
+        # Get final stats
+        stats_data = retriever.get_stats()
+
+        # Success message
+        console.print(f"\n[bold green]✓ Indexing complete![/bold green]\n")
+
+        # Show stats table
+        table = Table(show_header=False, box=None)
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", justify="right", style="bold green")
+
+        table.add_row("Total chunks indexed", str(stats_data['total_chunks']))
+        table.add_row("Indexed chunks", str(stats_data.get('indexed_chunks', stats_data['total_chunks'])))
+        table.add_row("Embedding dimension", str(stats_data['embedding_dimension']))
+        table.add_row("Hybrid search", "✓ Enabled" if stats_data.get('hybrid_search_enabled') else "✗ Disabled")
+
+        console.print(table)
+        console.print()
+
+        # Next steps
+        console.print("[bold]Next steps:[/bold]")
+        console.print("  • Search: [cyan]assistant search 'your query'[/cyan]")
+        console.print("  • Ask: [cyan]assistant ask 'your question'[/cyan]")
+        console.print("  • Explain: [cyan]assistant explain path/to/file.py[/cyan]")
+        console.print()
+
+    except Exception as e:
+        console.print(f"\n[red]✗ Indexing failed: {e}[/red]")
+        if settings.verbose:
+            import traceback
+            traceback.print_exc()
+        raise typer.Exit(1)