codegraph-cli 2.1.1__py3-none-any.whl → 2.1.2__py3-none-any.whl

codegraph_cli/cli_groups.py

@@ -0,0 +1,33 @@
+"""Command hierarchy groups for organized CLI experience.
+
+Provides logical grouping of commands under:
+  cg config   — Configuration management
+  cg project  — Project management
+  cg analyze  — Code analysis
+  cg chat     — Interactive AI chat
+"""
+
+from __future__ import annotations
+
+import typer
+
+# ── Configuration group ──────────────────────────────────────
+config_grp = typer.Typer(
+    help="⚙️  Configuration — LLM, embedding, and setup.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# ── Project management group ─────────────────────────────────
+project_grp = typer.Typer(
+    help="📂 Projects — index, load, and manage project memories.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# ── Analysis group ───────────────────────────────────────────
+analyze_grp = typer.Typer(
+    help="🔍 Analysis — search, impact, graph, and RAG context.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)

codegraph_cli/cli_health.py

@@ -0,0 +1,316 @@
+"""Project health dashboard for CodeGraph CLI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, TextColumn
+from rich.table import Table
+
+from . import config
+from .storage import GraphStore, ProjectManager
+
+console = Console()
+
+health_app = typer.Typer(help="🏥 Project health dashboard")
+
+
+def _render_bar(percentage: float) -> str:
+    """Render a simple text progress bar."""
+    filled = int(percentage / 10)
+    empty = 10 - filled
+    bar = "█" * filled + "░" * empty
+    if percentage >= 80:
+        color = "green"
+    elif percentage >= 60:
+        color = "yellow"
+    else:
+        color = "red"
+    return f"[{color}]{bar}[/{color}] {percentage:.0f}%"
+
+
+def _score_color(score: float) -> str:
+    if score >= 80:
+        return "green"
+    elif score >= 60:
+        return "yellow"
+    return "red"
+
+
+def _analyze_code_quality(store: GraphStore) -> Dict[str, Any]:
+    """Analyze code quality from indexed nodes."""
+    nodes = store.get_nodes()
+    if not nodes:
+        return {"score": 0, "total_nodes": 0, "functions": 0, "classes": 0}
+
+    functions = [n for n in nodes if n.get("node_type") == "function"]
+    classes = [n for n in nodes if n.get("node_type") == "class"]
+
+    # Heuristic quality score based on:
+    # - docstring presence
+    # - reasonable function size
+    # - naming conventions
+    score_points = 0
+    total_checks = 0
+
+    for fn in functions:
+        total_checks += 1
+        snippet = fn.get("snippet", "")
+        # Has docstring?
+        if '"""' in snippet or "'''" in snippet:
+            score_points += 1
+        else:
+            score_points += 0.3
+        # Reasonable size (< 50 lines)
+        start = fn.get("start_line", 0)
+        end = fn.get("end_line", 0)
+        if 0 < (end - start) < 50:
+            score_points += 0.5
+            total_checks += 0.5
+        else:
+            total_checks += 0.5
+
+    quality_pct = (score_points / max(total_checks, 1)) * 100
+    return {
+        "score": min(quality_pct, 100),
+        "total_nodes": len(nodes),
+        "functions": len(functions),
+        "classes": len(classes),
+        "documented": sum(
+            1 for fn in functions if '"""' in fn.get("snippet", "") or "'''" in fn.get("snippet", "")
+        ),
+    }
+
+
+def _analyze_complexity(store: GraphStore) -> Dict[str, Any]:
+    """Estimate code complexity from indexed functions."""
+    nodes = store.get_nodes()
+    functions = [n for n in nodes if n.get("node_type") == "function"]
+
+    if not functions:
+        return {"avg": 0, "max": 0, "high_complexity": []}
+
+    complexities = []
+    high_complexity = []
+
+    for fn in functions:
+        snippet = fn.get("snippet", "")
+        # Rough cyclomatic complexity estimate
+        complexity = 1  # base
+        for keyword in ["if ", "elif ", "else:", "for ", "while ", "except ", "and ", "or ", "case "]:
+            complexity += snippet.count(keyword)
+
+        complexities.append(complexity)
+        if complexity > 10:
+            high_complexity.append({
+                "name": fn.get("qualname", fn.get("name", "unknown")),
+                "complexity": complexity,
+                "file": fn.get("file_path", ""),
+            })
+
+    avg_complexity = sum(complexities) / len(complexities) if complexities else 0
+    max_complexity = max(complexities) if complexities else 0
+
+    return {
+        "avg": avg_complexity,
+        "max": max_complexity,
+        "high_complexity": sorted(high_complexity, key=lambda x: x["complexity"], reverse=True)[:10],
+    }
+
+
+def _analyze_security(store: GraphStore) -> Dict[str, Any]:
+    """Quick security scan from indexed code."""
+    nodes = store.get_nodes()
+    critical = 0
+    high = 0
+    medium = 0
+
+    security_patterns = {
+        "critical": ["eval(", "exec(", "os.system(", "subprocess.call(shell=True"],
+        "high": ["pickle.loads", "yaml.load(", "password", "secret", "SQL"],
+        "medium": ["print(", "TODO", "FIXME", "HACK"],
+    }
+
+    for node in nodes:
+        snippet = node.get("snippet", "")
+        for pattern in security_patterns["critical"]:
+            if pattern in snippet:
+                critical += 1
+        for pattern in security_patterns["high"]:
+            if pattern.lower() in snippet.lower():
+                high += 1
+        for pattern in security_patterns["medium"]:
+            if pattern in snippet:
+                medium += 1
+
+    return {"critical": critical, "high": high, "medium": medium}
+
+
+def _generate_recommendations(
+    quality: Dict[str, Any],
+    complexity: Dict[str, Any],
+    security: Dict[str, Any],
+) -> List[str]:
+    """Generate actionable recommendations."""
+    recs = []
+
+    documented = quality.get("documented", 0)
+    total_fns = quality.get("functions", 0)
+    if total_fns > 0 and documented / total_fns < 0.5:
+        recs.append(
+            f"Add docstrings: only {documented}/{total_fns} functions are documented. "
+            "Run 'cg v2 review <file>' for suggestions."
+        )
+
+    if security["critical"] > 0:
+        recs.append(
+            f"Fix {security['critical']} critical security pattern(s) (eval/exec/os.system). "
+            "Run 'cg v2 review <file> --check security'."
+        )
+
+    if security["high"] > 0:
+        recs.append(
+            f"Review {security['high']} high-severity pattern(s). "
+            "Run 'cg v2 review <file> --check security'."
+        )
+
+    if complexity["max"] > 15:
+        recs.append(
+            f"Refactor high-complexity functions (max: {complexity['max']}). "
+            "Run 'cg v2 refactor extract-function' to simplify."
+        )
+
+    if quality["score"] < 70:
+        recs.append("Run 'cg v2 review <file>' on low-quality modules to get improvement suggestions.")
+
+    if not recs:
+        recs.append("Your project looks healthy! Keep up the good work. 🎉")
+
+    return recs
+
+
+@health_app.command("dashboard")
+def health_dashboard():
+    """🏥 Project health dashboard.
+
+    Shows code quality, complexity, security patterns, and recommendations.
+
+    Example:
+      cg health dashboard
+    """
+    pm = ProjectManager()
+    project = pm.get_current_project()
+    if not project:
+        console.print("[red]✗[/red] No project loaded. Run 'cg index <path>' first.")
+        raise typer.Exit(1)
+
+    project_dir = pm.project_dir(project)
+    store = GraphStore(project_dir)
+
+    console.print(f"\n[bold cyan]🏥 Analyzing project health for '{project}'...[/bold cyan]\n")
+
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("[cyan]Running analyzers...", total=3)
+
+        progress.update(task, description="[cyan]Analyzing code quality...")
+        quality = _analyze_code_quality(store)
+        progress.advance(task)
+
+        progress.update(task, description="[cyan]Analyzing complexity...")
+        complexity = _analyze_complexity(store)
+        progress.advance(task)
+
+        progress.update(task, description="[cyan]Scanning for security patterns...")
+        security = _analyze_security(store)
+        progress.advance(task)
+
+    # ── Overall score ────────────────────────────────────────
+    quality_score = quality["score"]
+    complexity_penalty = min(complexity["avg"] * 2, 30)
+    security_penalty = security["critical"] * 10 + security["high"] * 3
+    overall = max(0, min(100, quality_score - complexity_penalty - security_penalty))
+    color = _score_color(overall)
+
+    console.print(
+        Panel.fit(
+            f"[bold {color}]{overall:.0f}%[/bold {color}]",
+            title="[bold]Overall Health Score[/bold]",
+            border_style=color,
+        )
+    )
+
+    # ── Detailed metrics ─────────────────────────────────────
+    table = Table(title="\nDetailed Metrics", show_header=True, show_lines=False)
+    table.add_column("Metric", style="cyan", width=18)
+    table.add_column("Score", width=24)
+    table.add_column("Details", min_width=30)
+
+    table.add_row(
+        "Code Quality",
+        _render_bar(quality_score),
+        f"{quality['functions']} functions, {quality['classes']} classes, "
+        f"{quality['documented']} documented",
+    )
+
+    complexity_pct = max(0, 100 - complexity["avg"] * 5)
+    table.add_row(
+        "Complexity",
+        _render_bar(complexity_pct),
+        f"Avg: {complexity['avg']:.1f}, Max: {complexity['max']}",
+    )
+
+    sec_pct = max(0, 100 - security["critical"] * 20 - security["high"] * 5 - security["medium"])
+    sec_status = (
+        "🔴 Critical" if security["critical"] > 0
+        else "🟡 Warning" if security["high"] > 0
+        else "🟢 Good"
+    )
+    table.add_row(
+        "Security",
+        sec_status,
+        f"{security['critical']} critical, {security['high']} high, {security['medium']} medium",
+    )
+
+    table.add_row(
+        "Total Nodes",
+        str(quality["total_nodes"]),
+        f"Indexed symbols in project '{project}'",
+    )
+
+    console.print(table)
+
+    # ── High complexity functions ────────────────────────────
+    if complexity["high_complexity"]:
+        console.print("\n[bold yellow]⚠️  High-Complexity Functions[/bold yellow]")
+        for item in complexity["high_complexity"][:5]:
+            console.print(f"  • {item['name']} (complexity: {item['complexity']}) — {item['file']}")
+
+    # ── Recommendations ──────────────────────────────────────
+    recs = _generate_recommendations(quality, complexity, security)
+    console.print(
+        "\n"
+        + Panel(
+            "\n".join([f"  • {rec}" for rec in recs]),
+            title="[bold yellow]📋 Recommendations[/bold yellow]",
+            border_style="yellow",
+        ).markup  # type: ignore
+        if False
+        else ""
+    )
+    console.print(
+        Panel(
+            "\n".join([f"  • {rec}" for rec in recs]),
+            title="[bold yellow]📋 Recommendations[/bold yellow]",
+            border_style="yellow",
+        )
+    )
+
+    store.close()

codegraph_cli/cli_history.py

@@ -0,0 +1,213 @@
+"""Undo/redo system and change history for CodeGraph CLI."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from .config import BASE_DIR
+
+console = Console()
+
+history_app = typer.Typer(help="📜 Change history and undo/redo")
+
+HISTORY_FILE = BASE_DIR / "change_history.json"
+MAX_HISTORY = 100
+
+
+class ChangeHistory:
+    """Track code changes for undo/redo support."""
+
+    def __init__(self):
+        self.history: List[dict] = self._load()
+        self.current_index: int = len(self.history) - 1
+
+    def _load(self) -> List[dict]:
+        if HISTORY_FILE.exists():
+            try:
+                return json.loads(HISTORY_FILE.read_text())
+            except (json.JSONDecodeError, OSError):
+                return []
+        return []
+
+    def _save(self) -> None:
+        HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
+        # Trim to max history
+        data = self.history[-MAX_HISTORY:]
+        HISTORY_FILE.write_text(json.dumps(data, indent=2))
+
+    def record_change(
+        self,
+        change_type: str,
+        description: str,
+        files_changed: List[str],
+        backup_id: str,
+    ) -> None:
+        """Record a change for undo/redo."""
+        # Truncate any "future" entries if we've undone things
+        self.history = self.history[: self.current_index + 1]
+        self.history.append(
+            {
+                "timestamp": datetime.now().isoformat(),
+                "type": change_type,
+                "description": description,
+                "files": files_changed,
+                "backup_id": backup_id,
+            }
+        )
+        self.current_index = len(self.history) - 1
+        self._save()
+
+    def can_undo(self) -> bool:
+        return self.current_index >= 0 and len(self.history) > 0
+
+    def can_redo(self) -> bool:
+        return self.current_index < len(self.history) - 1
+
+    def get_undo_entry(self) -> Optional[dict]:
+        if not self.can_undo():
+            return None
+        entry = self.history[self.current_index]
+        self.current_index -= 1
+        self._save()
+        return entry
+
+    def get_redo_entry(self) -> Optional[dict]:
+        if not self.can_redo():
+            return None
+        self.current_index += 1
+        entry = self.history[self.current_index]
+        self._save()
+        return entry
+
+
+@history_app.command("undo")
+def undo(
+    steps: int = typer.Option(1, "--steps", "-n", min=1, help="Number of steps to undo."),
+):
+    """⏪ Undo last code changes.
+
+    Restores files from backups created during generate, refactor, or fix operations.
+
+    Example:
+      cg undo
+      cg undo --steps 3
+    """
+    from .diff_engine import DiffEngine
+
+    hist = ChangeHistory()
+
+    if not hist.can_undo():
+        console.print("[yellow]No changes to undo.[/yellow]")
+        return
+
+    diff_engine = DiffEngine()
+    undone = 0
+
+    for _ in range(steps):
+        entry = hist.get_undo_entry()
+        if not entry:
+            console.print("[yellow]No more changes to undo.[/yellow]")
+            break
+
+        console.print(f"  [yellow]⏪ Undoing:[/yellow] {entry['description']}")
+
+        success = diff_engine.rollback(entry["backup_id"])
+        if success:
+            console.print(f"  [green]✓[/green] Restored {len(entry['files'])} file(s)")
+            undone += 1
+        else:
+            console.print(f"  [red]✗[/red] Backup not found: {entry['backup_id']}")
+
+    if undone:
+        console.print(f"\n[green]Undid {undone} change(s).[/green]")
+        console.print("[dim]Use 'cg redo' to reapply.[/dim]")
+
+
+@history_app.command("redo")
+def redo(
+    steps: int = typer.Option(1, "--steps", "-n", min=1, help="Number of steps to redo."),
+):
+    """⏩ Redo previously undone changes.
+
+    Example:
+      cg redo
+      cg redo --steps 2
+    """
+    hist = ChangeHistory()
+
+    if not hist.can_redo():
+        console.print("[yellow]No changes to redo.[/yellow]")
+        return
+
+    console.print("[cyan]Redo is not yet fully supported — please re-run the command.[/cyan]")
+    console.print("[dim]History tracking is active; full redo support coming soon.[/dim]")
+
+
+@history_app.command("show")
+def show_history(
+    limit: int = typer.Option(10, "--limit", "-n", min=1, help="Number of entries to show."),
+):
+    """📜 Show change history.
+
+    Example:
+      cg history show
+      cg history show --limit 20
+    """
+    hist = ChangeHistory()
+
+    if not hist.history:
+        console.print("[yellow]No change history yet.[/yellow]")
+        console.print("[dim]History is recorded when you generate, refactor, or fix code.[/dim]")
+        return
+
+    table = Table(title="Change History", show_lines=False)
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Time", style="cyan", width=16)
+    table.add_column("Type", style="magenta", width=12)
+    table.add_column("Description", min_width=30)
+    table.add_column("Files", justify="right", style="green", width=6)
+
+    entries = hist.history[-limit:]
+    for i, change in enumerate(reversed(entries), 1):
+        try:
+            timestamp = datetime.fromisoformat(change["timestamp"])
+            time_str = timestamp.strftime("%Y-%m-%d %H:%M")
+        except (ValueError, KeyError):
+            time_str = "unknown"
+
+        marker = " ◄" if (len(hist.history) - i) == hist.current_index else ""
+        table.add_row(
+            str(i),
+            time_str,
+            change.get("type", "unknown"),
+            change.get("description", "—") + marker,
+            str(len(change.get("files", []))),
+        )
+
+    console.print(table)
+    console.print(f"\n[dim]Showing {len(entries)} of {len(hist.history)} entries[/dim]")
+
+
+@history_app.command("clear")
+def clear_history():
+    """🗑️  Clear all change history.
+
+    Example:
+      cg history clear
+    """
+    if not HISTORY_FILE.exists():
+        console.print("[yellow]No history to clear.[/yellow]")
+        return
+
+    if typer.confirm("Clear all change history?", default=False):
+        HISTORY_FILE.unlink(missing_ok=True)
+        console.print("[green]✓ History cleared.[/green]")
+    else:
+        console.print("[dim]Cancelled.[/dim]")