codegraph-cli 2.0.0__py3-none-any.whl

codegraph_cli/cli_v2.py

@@ -0,0 +1,267 @@
+"""CLI commands for v2.0 code generation features."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from . import config
+from .cli_diagnose import diagnose_app
+from .cli_refactor import refactor_app
+from .cli_test import test_app
+from .codegen_agent import CodeGenAgent
+from .diff_engine import DiffEngine
+from .llm import LocalLLM
+from .storage import GraphStore, ProjectManager
+
+# Create sub-app for v2 commands
+v2_app = typer.Typer(help="v2.0 code generation features (experimental)")
+
+# Register sub-commands under v2
+v2_app.add_typer(refactor_app, name="refactor")
+v2_app.add_typer(diagnose_app, name="diagnose")
+v2_app.add_typer(test_app, name="test")
+
+
+def _get_codegen_agent(pm: ProjectManager) -> CodeGenAgent:
+    """Get CodeGenAgent with current project context."""
+    project = pm.get_current_project()
+    if not project:
+        raise typer.BadParameter("No project loaded. Use 'cg load-project <name>' or run 'cg index <path>'.")
+    
+    project_dir = pm.project_dir(project)
+    if not project_dir.exists():
+        raise typer.BadParameter(f"Loaded project '{project}' does not exist in memory.")
+    
+    store = GraphStore(project_dir)
+    llm = LocalLLM(
+        model=config.LLM_MODEL,
+        provider=config.LLM_PROVIDER,
+        api_key=config.LLM_API_KEY
+    )
+    
+    return CodeGenAgent(store, llm)
+
+
+@v2_app.command("generate")
+def generate_code(
+    prompt: str = typer.Argument(..., help="Natural language description of code to generate"),
+    context_file: Optional[str] = typer.Option(None, "--file", "-f", help="File to use as context"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output file path or directory"),
+    preview_only: bool = typer.Option(False, "--preview", "-p", help="Preview changes without applying"),
+    auto_apply: bool = typer.Option(False, "--auto-apply", "-y", help="Apply changes without confirmation"),
+    llm_provider: str = typer.Option(config.LLM_PROVIDER, help="LLM provider"),
+    llm_api_key: Optional[str] = typer.Option(config.LLM_API_KEY, help="API key for LLM"),
+    llm_model: str = typer.Option(config.LLM_MODEL, help="LLM model"),
+):
+    """Generate code from natural language description (v2.0 experimental)."""
+    pm = ProjectManager()
+    agent = _get_codegen_agent(pm)
+    
+    typer.echo("🤖 Generating code...")
+    
+    # Generate code
+    proposal = agent.generate(prompt, context_file=context_file)
+    
+    # Update file paths if output directory specified
+    if output:
+        output_path = Path(output)
+        for change in proposal.changes:
+            if output_path.is_dir() or not output_path.suffix:
+                # Output is a directory
+                output_path.mkdir(parents=True, exist_ok=True)
+                filename = Path(change.file_path).name
+                change.file_path = str(output_path / filename)
+            else:
+                # Output is a specific file
+                change.file_path = str(output_path)
+    
+    # Preview changes
+    diff_engine = DiffEngine()
+    preview = diff_engine.preview_changes(proposal)
+    typer.echo(preview)
+    
+    # Analyze impact
+    typer.echo("")
+    impact = agent.preview_impact(proposal)
+    typer.echo(impact)
+    
+    # Apply if requested
+    if preview_only:
+        typer.echo("\n📋 Preview only mode - no changes applied")
+        return
+    
+    if not auto_apply:
+        apply = typer.confirm("\n❓ Apply these changes?", default=False)
+        if not apply:
+            typer.echo("❌ Changes not applied")
+            return
+    
+    # Apply changes
+    typer.echo("\n✨ Applying changes...")
+    result = agent.apply_changes(proposal)
+    
+    if result.success:
+        typer.echo(f"✅ Successfully applied changes to {len(result.files_changed)} file(s)")
+        if result.backup_id:
+            typer.echo(f"💾 Backup created: {result.backup_id}")
+            typer.echo(f"   Rollback with: cg v2 rollback {result.backup_id}")
+    else:
+        typer.echo(f"❌ Failed to apply changes: {result.error}")
+
+
+@v2_app.command("rollback")
+def rollback_changes(
+    backup_id: str = typer.Argument(..., help="Backup ID to rollback to"),
+):
+    """Rollback to a previous backup."""
+    diff_engine = DiffEngine()
+    
+    typer.echo(f"🔄 Rolling back to backup: {backup_id}")
+    success = diff_engine.rollback(backup_id)
+    
+    if success:
+        typer.echo("✅ Successfully rolled back changes")
+    else:
+        typer.echo(f"❌ Failed to rollback - backup not found: {backup_id}")
+
+
+@v2_app.command("list-backups")
+def list_backups():
+    """List all available backups."""
+    diff_engine = DiffEngine()
+    backups = diff_engine.list_backups()
+    
+    if not backups:
+        typer.echo("No backups found")
+        return
+    
+    typer.echo(f"📦 Found {len(backups)} backup(s):\n")
+    for backup in backups:
+        typer.echo(f"ID: {backup['backup_id']}")
+        typer.echo(f"   Description: {backup['description']}")
+        typer.echo(f"   Timestamp: {backup['timestamp']}")
+        typer.echo(f"   Files: {len(backup['files'])}")
+        typer.echo("")
+
+
+@v2_app.command("review")
+def review_code(
+    file_path: str = typer.Argument(..., help="File to review"),
+    check: str = typer.Option("all", help="Check type: bugs, security, performance, all"),
+    severity: str = typer.Option("all", help="Minimum severity: low, medium, high, critical"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed output"),
+    use_llm: bool = typer.Option(False, "--llm", help="Use LLM for deeper analysis"),
+    show_fixes: bool = typer.Option(False, "--fix", help="Show auto-fix suggestions"),
+):
+    """Run AI-powered code review on a file."""
+    from .bug_detector import BugDetector
+    from .security_scanner import SecurityScanner
+    from .performance_analyzer import PerformanceAnalyzer
+    
+    pm = ProjectManager()
+    project = pm.get_current_project()
+    if not project:
+        typer.echo("❌ No project loaded. Use 'cg load-project <name>' first.", err=True)
+        raise typer.Exit(1)
+    
+    project_dir = pm.project_dir(project)
+    store = GraphStore(project_dir)
+    llm = LocalLLM(
+        model=config.LLM_MODEL,
+        provider=config.LLM_PROVIDER,
+        api_key=config.LLM_API_KEY
+    ) if use_llm else None
+    
+    all_issues = []
+    
+    # Run selected checks
+    typer.echo(f"🔍 Analyzing {file_path}...")
+    if use_llm:
+        typer.echo("  🤖 LLM analysis enabled")
+    if show_fixes:
+        typer.echo("  🔧 Auto-fix suggestions enabled")
+    typer.echo("")
+    
+    if check in ["bugs", "all"]:
+        detector = BugDetector(store, llm)
+        bug_issues = detector.analyze_file(file_path, use_llm=use_llm)
+        all_issues.extend(bug_issues)
+        if verbose:
+            typer.echo(f"  Bug detection: {len(bug_issues)} issue(s)")
+    
+    if check in ["security", "all"]:
+        scanner = SecurityScanner(store)
+        security_issues = scanner.scan_file(file_path, generate_fixes=show_fixes)
+        all_issues.extend(security_issues)
+        if verbose:
+            typer.echo(f"  Security scan: {len(security_issues)} issue(s)")
+    
+    if check in ["performance", "all"]:
+        analyzer = PerformanceAnalyzer(store)
+        perf_issues = analyzer.analyze_file(file_path)
+        all_issues.extend(perf_issues)
+        if verbose:
+            typer.echo(f"  Performance analysis: {len(perf_issues)} issue(s)")
+    
+    # Filter by severity
+    if severity != "all":
+        severity_order = ["low", "medium", "high", "critical"]
+        min_level = severity_order.index(severity)
+        all_issues = [
+            i for i in all_issues 
+            if severity_order.index(i["severity"]) >= min_level
+        ]
+    
+    # Display results
+    if not all_issues:
+        typer.echo("✅ No issues found!")
+        store.close()
+        return
+    
+    typer.echo(f"\n🔍 Found {len(all_issues)} issue(s):\n")
+    
+    # Group by severity
+    by_severity = {"critical": [], "high": [], "medium": [], "low": []}
+    for issue in all_issues:
+        by_severity[issue["severity"]].append(issue)
+    
+    severity_icons = {
+        "critical": "🚨",
+        "high": "🔴",
+        "medium": "⚠️",
+        "low": "ℹ️"
+    }
+    
+    # Display grouped by severity
+    for sev in ["critical", "high", "medium", "low"]:
+        issues = by_severity[sev]
+        if not issues:
+            continue
+        
+        typer.echo(f"{severity_icons[sev]} {sev.upper()} ({len(issues)} issue(s)):")
+        for issue in sorted(issues, key=lambda x: x["line"]):
+            typer.echo(f"  Line {issue['line']}: {issue['message']}")
+            typer.echo(f"    Type: {issue['type']}")
+            
+            if verbose and "code_snippet" in issue:
+                typer.echo(f"    Code: {issue['code_snippet']}")
+            
+            # Show LLM explanation if available
+            if "llm_explanation" in issue:
+                typer.echo(f"    🤖 Analysis: {issue['llm_explanation']}")
+            
+            typer.echo(f"    💡 {issue['suggestion']}")
+            
+            # Show auto-fix if available
+            if show_fixes and "auto_fix" in issue:
+                typer.echo(f"    🔧 Auto-fix:")
+                for line in issue["auto_fix"].split("\n"):
+                    typer.echo(f"       {line}")
+            
+            typer.echo("")
+    
+    store.close()
+

codegraph_cli/codegen_agent.py

@@ -0,0 +1,265 @@
+"""CodeGenAgent for AI-powered code generation with impact analysis."""
+
+from __future__ import annotations
+
+import uuid
+from pathlib import Path
+from typing import Optional
+
+from .diff_engine import DiffEngine
+from .llm import LocalLLM
+from .models_v2 import ApplyResult, CodeProposal, FileChange
+from .orchestrator import MCPOrchestrator
+from .storage import GraphStore
+
+
+class CodeGenAgent:
+    """Generates code based on natural language requests with impact preview."""
+    
+    def __init__(
+        self,
+        store: GraphStore,
+        llm: LocalLLM,
+        diff_engine: Optional[DiffEngine] = None,
+        project_context=None  # ProjectContext for file operations
+    ):
+        """Initialize CodeGenAgent.
+        
+        Args:
+            store: Graph store for context
+            llm: LLM for code generation
+            diff_engine: Engine for managing diffs (optional)
+            project_context: ProjectContext for file operations (optional)
+        """
+        self.store = store
+        self.llm = llm
+        self.diff_engine = diff_engine or DiffEngine()
+        self.project_context = project_context
+        # Pass provider name as string, not the provider object
+        self.orchestrator = MCPOrchestrator(
+            store,
+            llm_model=llm.model,
+            llm_provider=llm.provider_name,  # Fixed: use provider_name string
+            llm_api_key=llm.api_key
+        )
+    
+    def generate(
+        self,
+        prompt: str,
+        context_file: Optional[str] = None,
+        max_files: int = 3
+    ) -> CodeProposal:
+        """Generate code from natural language prompt.
+        
+        Args:
+            prompt: Natural language description of what to generate
+            context_file: Optional file to use as context
+            max_files: Maximum number of context files to include
+            
+        Returns:
+            CodeProposal with generated changes
+        """
+        # Gather context from codebase
+        context = self._gather_context(prompt, context_file, max_files)
+        
+        # Generate code using LLM
+        generation_prompt = self._build_generation_prompt(prompt, context)
+        generated_code = self.llm.explain(generation_prompt)
+        
+        # Parse generated code into changes
+        changes = self._parse_generated_code(generated_code, prompt)
+        
+        # Create proposal
+        proposal = CodeProposal(
+            id=str(uuid.uuid4()),
+            description=prompt,
+            changes=changes,
+            metadata={"context_files": context.get("files", [])}
+        )
+        
+        # Add diffs for modified files
+        for change in proposal.changes:
+            if change.change_type == "modify" and change.original_content and change.new_content:
+                change.diff = self.diff_engine.create_diff(
+                    change.original_content,
+                    change.new_content,
+                    change.file_path
+                )
+        
+        return proposal
+    
+    def preview_impact(self, proposal: CodeProposal) -> str:
+        """Analyze impact of proposed changes.
+        
+        Args:
+            proposal: Code proposal to analyze
+            
+        Returns:
+            Impact analysis summary
+        """
+        impact_lines = []
+        
+        # Analyze each change
+        for change in proposal.changes:
+            if change.change_type == "create":
+                impact_lines.append(f"✨ New file: {change.file_path}")
+            elif change.change_type == "modify":
+                # Try to find affected symbols
+                file_path = Path(change.file_path)
+                if file_path.exists():
+                    impact_lines.append(f"📝 Modified: {change.file_path}")
+                    # Could add more detailed analysis here
+            elif change.change_type == "delete":
+                impact_lines.append(f"🗑️  Deleted: {change.file_path}")
+        
+        # Add recommendations
+        impact_lines.append("")
+        impact_lines.append("💡 Recommendations:")
+        impact_lines.append("  - Review generated code for correctness")
+        impact_lines.append("  - Run tests after applying changes")
+        impact_lines.append("  - Backup is created automatically")
+        
+        return "\n".join(impact_lines)
+    
+    def apply_changes(
+        self,
+        proposal: CodeProposal,
+        backup: bool = True
+    ) -> ApplyResult:
+        """Apply proposed changes to filesystem.
+        
+        Args:
+            proposal: Proposal to apply
+            backup: Whether to create backup
+            
+        Returns:
+            Result of applying changes
+        """
+        return self.diff_engine.apply_changes(proposal, backup=backup)
+    
+    def _gather_context(
+        self,
+        prompt: str,
+        context_file: Optional[str],
+        max_files: int
+    ) -> dict:
+        """Gather relevant context from codebase.
+        
+        Args:
+            prompt: User's request
+            context_file: Specific file to include
+            max_files: Max number of files to include
+            
+        Returns:
+            Context dictionary
+        """
+        context = {"files": [], "snippets": []}
+        
+        # If specific file provided, use it
+        if context_file:
+            file_path = Path(context_file)
+            if file_path.exists():
+                context["files"].append({
+                    "path": str(file_path),
+                    "content": file_path.read_text()
+                })
+        
+        # Search for relevant code
+        try:
+            search_results = self.orchestrator.search(prompt, top_k=max_files)
+            for result in search_results[:max_files]:
+                context["snippets"].append({
+                    "qualname": result.qualname,
+                    "file": result.file_path,
+                    "code": result.code
+                })
+        except Exception:
+            pass  # Continue even if search fails
+        
+        return context
+    
+    def _build_generation_prompt(self, user_prompt: str, context: dict) -> str:
+        """Build prompt for LLM code generation.
+        
+        Args:
+            user_prompt: User's request
+            context: Gathered context
+            
+        Returns:
+            Formatted prompt for LLM
+        """
+        prompt_parts = []
+        
+        prompt_parts.append("You are a code generation assistant. Generate clean, working code based on the user's request.")
+        prompt_parts.append("")
+        prompt_parts.append(f"User Request: {user_prompt}")
+        prompt_parts.append("")
+        
+        # Add context if available
+        if context.get("snippets"):
+            prompt_parts.append("Relevant existing code:")
+            for snippet in context["snippets"][:3]:
+                prompt_parts.append(f"\n# {snippet['qualname']} ({snippet['file']})")
+                prompt_parts.append(snippet["code"][:500])  # Limit length
+            prompt_parts.append("")
+        
+        prompt_parts.append("Generate the requested code. Include:")
+        prompt_parts.append("1. Complete, working implementation")
+        prompt_parts.append("2. Proper error handling")
+        prompt_parts.append("3. Clear docstrings")
+        prompt_parts.append("4. Type hints where appropriate")
+        prompt_parts.append("")
+        prompt_parts.append("Output only the code, no explanations.")
+        
+        return "\n".join(prompt_parts)
+    
+    def _parse_generated_code(self, generated: str, prompt: str) -> list[FileChange]:
+        """Parse LLM output into file changes.
+        
+        Args:
+            generated: Generated code from LLM
+            prompt: Original user prompt
+            
+        Returns:
+            List of FileChange objects
+        """
+        # Simple implementation: treat as new file
+        # In production, would parse file markers, detect modifications, etc.
+        
+        # Try to infer filename from prompt
+        filename = self._infer_filename(prompt)
+        
+        return [
+            FileChange(
+                file_path=filename,
+                change_type="create",
+                new_content=generated.strip()
+            )
+        ]
+    
+    def _infer_filename(self, prompt: str) -> str:
+        """Infer filename from user prompt.
+        
+        Args:
+            prompt: User's request
+            
+        Returns:
+            Suggested filename (relative to project source if context available)
+        """
+        # Simple heuristic: look for common patterns
+        prompt_lower = prompt.lower()
+        
+        if "test" in prompt_lower:
+            basename = "test_generated.py"
+        elif "api" in prompt_lower or "endpoint" in prompt_lower:
+            basename = "api_generated.py"
+        elif "model" in prompt_lower:
+            basename = "models_generated.py"
+        else:
+            basename = "generated.py"
+        
+        # If we have project context, prepend source path
+        if self.project_context and self.project_context.has_source_access:
+            return str(self.project_context.source_path / basename)
+        else:
+            return basename

codegraph_cli/config.py

@@ -0,0 +1,31 @@
+"""Configuration paths for local CodeGraph memory."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+BASE_DIR = Path(os.environ.get("CODEGRAPH_HOME", str(Path.home() / ".codegraph"))).expanduser()
+MEMORY_DIR = BASE_DIR / "memory"
+STATE_FILE = BASE_DIR / "state.json"
+DEFAULT_EMBEDDING_DIM = 256
+SUPPORTED_EXTENSIONS = {".py"}
+
+# Load configuration from TOML file (if available)
+try:
+    from .config_manager import load_config
+    _toml_config = load_config()
+except ImportError:
+    _toml_config = {}
+
+# LLM Provider Configuration — loaded from ~/.codegraph/config.toml (set via `cg setup` or `cg set-llm`)
+LLM_PROVIDER = _toml_config.get("provider", "ollama")
+LLM_API_KEY = _toml_config.get("api_key", "")
+LLM_MODEL = _toml_config.get("model", "qwen2.5-coder:7b")
+LLM_ENDPOINT = _toml_config.get("endpoint", "http://127.0.0.1:11434/api/generate")
+
+
+def ensure_base_dirs() -> None:
+    """Create base directories for local storage if needed."""
+    MEMORY_DIR.mkdir(parents=True, exist_ok=True)
+    BASE_DIR.mkdir(parents=True, exist_ok=True)