codegraph-cli 2.0.0__py3-none-any.whl

codegraph_cli/diff_engine.py

@@ -0,0 +1,265 @@
+"""DiffEngine for previewing and applying code changes."""
+
+from __future__ import annotations
+
+import difflib
+import shutil
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from .models_v2 import ApplyResult, CodeProposal, FileChange
+
+
+class DiffEngine:
+    """Handles previewing and applying code changes safely."""
+    
+    def __init__(self, backup_dir: Optional[Path] = None):
+        """Initialize DiffEngine.
+        
+        Args:
+            backup_dir: Directory to store backups. Defaults to .codegraph/backups/
+        """
+        self.backup_dir = backup_dir or Path.home() / ".codegraph" / "backups"
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+    
+    def create_diff(self, original: str, modified: str, filename: str = "file") -> str:
+        """Create unified diff between two versions.
+        
+        Args:
+            original: Original content
+            modified: Modified content
+            filename: Name of file for diff header
+            
+        Returns:
+            Unified diff string
+        """
+        original_lines = original.splitlines(keepends=True)
+        modified_lines = modified.splitlines(keepends=True)
+        
+        diff = difflib.unified_diff(
+            original_lines,
+            modified_lines,
+            fromfile=f"a/{filename}",
+            tofile=f"b/{filename}",
+            lineterm=""
+        )
+        
+        return "".join(diff)
+    
+    def preview_changes(self, proposal: CodeProposal) -> str:
+        """Generate preview of all changes in a proposal.
+        
+        Args:
+            proposal: Code proposal to preview
+            
+        Returns:
+            Formatted preview string
+        """
+        lines = []
+        lines.append(f"📝 Proposed Changes: {proposal.description}")
+        lines.append(f"   ID: {proposal.id}")
+        lines.append("")
+        
+        # Summary
+        if proposal.num_files_created > 0:
+            lines.append(f"   [NEW] {proposal.num_files_created} file(s)")
+        if proposal.num_files_modified > 0:
+            lines.append(f"   [MODIFY] {proposal.num_files_modified} file(s)")
+        if proposal.num_files_deleted > 0:
+            lines.append(f"   [DELETE] {proposal.num_files_deleted} file(s)")
+        lines.append("")
+        
+        # Detailed changes
+        for change in proposal.changes:
+            lines.append(f"{'='*60}")
+            lines.append(f"[{change.change_type.upper()}] {change.file_path}")
+            lines.append(f"{'='*60}")
+            
+            if change.change_type == "create":
+                lines.append(change.new_content or "")
+            elif change.change_type == "delete":
+                lines.append(f"File will be deleted")
+            elif change.change_type == "modify":
+                if change.diff:
+                    lines.append(change.diff)
+                else:
+                    # Generate diff if not provided
+                    diff = self.create_diff(
+                        change.original_content or "",
+                        change.new_content or "",
+                        change.file_path
+                    )
+                    lines.append(diff)
+            lines.append("")
+        
+        # Impact summary
+        if proposal.impact_summary:
+            lines.append(f"{'='*60}")
+            lines.append("📊 Impact Analysis")
+            lines.append(f"{'='*60}")
+            lines.append(proposal.impact_summary)
+        
+        return "\n".join(lines)
+    
+    def apply_changes(
+        self,
+        proposal: CodeProposal,
+        backup: bool = True,
+        dry_run: bool = False
+    ) -> ApplyResult:
+        """Apply changes from a proposal to the filesystem.
+        
+        Args:
+            proposal: Code proposal to apply
+            backup: Whether to create backups before applying
+            dry_run: If True, don't actually apply changes
+            
+        Returns:
+            ApplyResult with success status and details
+        """
+        if dry_run:
+            return ApplyResult(
+                success=True,
+                files_changed=[c.file_path for c in proposal.changes],
+                backup_id=None
+            )
+        
+        backup_id = None
+        if backup:
+            backup_id = self._create_backup(proposal)
+        
+        files_changed = []
+        
+        try:
+            for change in proposal.changes:
+                file_path = Path(change.file_path)
+                
+                if change.change_type == "create":
+                    # Create new file
+                    file_path.parent.mkdir(parents=True, exist_ok=True)
+                    file_path.write_text(change.new_content or "")
+                    files_changed.append(str(file_path))
+                
+                elif change.change_type == "modify":
+                    # Modify existing file
+                    if not file_path.exists():
+                        raise FileNotFoundError(f"File not found: {file_path}")
+                    file_path.write_text(change.new_content or "")
+                    files_changed.append(str(file_path))
+                
+                elif change.change_type == "delete":
+                    # Delete file
+                    if file_path.exists():
+                        file_path.unlink()
+                        files_changed.append(str(file_path))
+            
+            return ApplyResult(
+                success=True,
+                files_changed=files_changed,
+                backup_id=backup_id
+            )
+        
+        except Exception as e:
+            # Rollback if backup exists
+            if backup_id:
+                self.rollback(backup_id)
+            
+            return ApplyResult(
+                success=False,
+                files_changed=[],
+                error=str(e)
+            )
+    
+    def _create_backup(self, proposal: CodeProposal) -> str:
+        """Create backup of files before applying changes.
+        
+        Args:
+            proposal: Proposal containing files to backup
+            
+        Returns:
+            Backup ID for rollback
+        """
+        backup_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+        backup_path = self.backup_dir / backup_id
+        backup_path.mkdir(parents=True, exist_ok=True)
+        
+        # Save metadata
+        metadata = {
+            "proposal_id": proposal.id,
+            "description": proposal.description,
+            "timestamp": datetime.now().isoformat(),
+            "files": []
+        }
+        
+        # Backup each file
+        for change in proposal.changes:
+            file_path = Path(change.file_path)
+            
+            if change.change_type in ["modify", "delete"] and file_path.exists():
+                # Copy original file to backup
+                backup_file = backup_path / file_path.name
+                shutil.copy2(file_path, backup_file)
+                metadata["files"].append({
+                    "original": str(file_path),
+                    "backup": str(backup_file),
+                    "change_type": change.change_type
+                })
+        
+        # Save metadata
+        import json
+        (backup_path / "metadata.json").write_text(json.dumps(metadata, indent=2))
+        
+        return backup_id
+    
+    def rollback(self, backup_id: str) -> bool:
+        """Rollback changes using a backup.
+        
+        Args:
+            backup_id: ID of backup to restore
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        backup_path = self.backup_dir / backup_id
+        
+        if not backup_path.exists():
+            return False
+        
+        try:
+            # Load metadata
+            import json
+            metadata = json.loads((backup_path / "metadata.json").read_text())
+            
+            # Restore each file
+            for file_info in metadata["files"]:
+                original_path = Path(file_info["original"])
+                backup_file = Path(file_info["backup"])
+                
+                if backup_file.exists():
+                    shutil.copy2(backup_file, original_path)
+            
+            return True
+        
+        except Exception:
+            return False
+    
+    def list_backups(self) -> list[dict]:
+        """List all available backups.
+        
+        Returns:
+            List of backup metadata
+        """
+        backups = []
+        
+        for backup_dir in self.backup_dir.iterdir():
+            if backup_dir.is_dir():
+                metadata_file = backup_dir / "metadata.json"
+                if metadata_file.exists():
+                    import json
+                    metadata = json.loads(metadata_file.read_text())
+                    metadata["backup_id"] = backup_dir.name
+                    backups.append(metadata)
+        
+        return sorted(backups, key=lambda x: x["timestamp"], reverse=True)

codegraph_cli/embeddings.py

@@ -0,0 +1,241 @@
+"""Neural embedding engine using Sentence Transformers for semantic code understanding.
+
+Local-first architecture:
+- Models are downloaded once and cached in ``~/.codegraph/models``.
+- All inference runs on-device (CPU or GPU).  No data is ever sent to
+  external APIs.
+
+Falls back to a lightweight deterministic hash-embedding when
+``sentence-transformers`` is not installed.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import os
+import re
+from hashlib import blake2b
+from pathlib import Path
+from typing import Iterable, List, Optional, Union
+
+from .config import BASE_DIR
+
+logger = logging.getLogger(__name__)
+
+# Default local model cache directory
+MODEL_CACHE_DIR: Path = BASE_DIR / "models"
+
+# Preferred models in priority order
+PREFERRED_MODELS: List[str] = [
+    "all-MiniLM-L6-v2",
+    "nomic-ai/nomic-embed-text-v1.5",
+]
+
+_TOKEN_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+
+
+# ===================================================================
+# NeuralEmbedder  (Primary – Sentence Transformers)
+# ===================================================================
+
+class NeuralEmbedder:
+    """Semantic embedding engine powered by Sentence Transformers.
+
+    The model is downloaded on first use and cached in
+    ``~/.codegraph/models`` so that subsequent runs are fully offline.
+    All computation is local – **no data leaves the machine**.
+
+    Example::
+
+        embedder = NeuralEmbedder()
+        vecs = embedder.embed_documents(["def hello(): ...", "class Foo: ..."])
+    """
+
+    def __init__(
+        self,
+        model_name: str = "all-MiniLM-L6-v2",
+        cache_dir: Optional[Path] = None,
+        device: str = "cpu",
+    ) -> None:
+        self.model_name = model_name
+        self.cache_dir = cache_dir or MODEL_CACHE_DIR
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.device = device
+        self._model: object = None  # lazy-loaded SentenceTransformer
+        self._dim: Optional[int] = None
+
+    # ------------------------------------------------------------------
+    # Lazy model loading
+    # ------------------------------------------------------------------
+
+    def _load_model(self) -> None:
+        if self._model is not None:
+            return
+
+        try:
+            from sentence_transformers import SentenceTransformer  # type: ignore[import-untyped]
+        except ImportError:
+            raise ImportError(
+                "sentence-transformers is not installed. "
+                "Install with:  pip install sentence-transformers"
+            )
+
+        # Tell sentence-transformers where to cache
+        os.environ.setdefault(
+            "SENTENCE_TRANSFORMERS_HOME", str(self.cache_dir),
+        )
+
+        try:
+            self._model = SentenceTransformer(
+                self.model_name,
+                cache_folder=str(self.cache_dir),
+                device=self.device,
+            )
+            self._dim = self._model.get_sentence_embedding_dimension()  # type: ignore[union-attr]
+            logger.info(
+                "Loaded model '%s' (dim=%d) on %s",
+                self.model_name, self._dim, self.device,
+            )
+        except Exception as exc:
+            raise RuntimeError(
+                f"Failed to load embedding model '{self.model_name}': {exc}"
+            ) from exc
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    @property
+    def dim(self) -> int:
+        """Dimensionality of the embedding vectors."""
+        if self._dim is None:
+            self._load_model()
+        assert self._dim is not None
+        return self._dim
+
+    def embed_text(self, text: str) -> List[float]:
+        """Embed a single text string and return a unit-norm vector."""
+        self._load_model()
+        assert self._model is not None
+        embedding = self._model.encode(  # type: ignore[union-attr]
+            text,
+            convert_to_numpy=True,
+            normalize_embeddings=True,
+            show_progress_bar=False,
+        )
+        return embedding.tolist()
+
+    def embed_documents(
+        self,
+        texts: List[str],
+        batch_size: int = 32,
+    ) -> List[List[float]]:
+        """Embed multiple documents with batching for efficiency.
+
+        Args:
+            texts: List of text strings to embed.
+            batch_size: Number of texts per forward pass.
+
+        Returns:
+            List of embedding vectors (each normalised to unit length).
+        """
+        if not texts:
+            return []
+        self._load_model()
+        assert self._model is not None
+        embeddings = self._model.encode(  # type: ignore[union-attr]
+            texts,
+            batch_size=batch_size,
+            convert_to_numpy=True,
+            normalize_embeddings=True,
+            show_progress_bar=len(texts) > 100,
+        )
+        return embeddings.tolist()
+
+    # Backward-compat alias used by legacy callers
+    def embed_many(self, texts: Iterable[str]) -> List[List[float]]:
+        """Alias for :meth:`embed_documents`."""
+        return self.embed_documents(list(texts))
+
+
+# ===================================================================
+# HashEmbeddingModel  (Lightweight Fallback)
+# ===================================================================
+
+class HashEmbeddingModel:
+    """Deterministic token-hashing embedder – no ML dependencies.
+
+    Provides basic keyword-level similarity.  Automatically used as a
+    fallback when ``sentence-transformers`` is not available.
+    """
+
+    def __init__(self, dim: int = 256) -> None:
+        self.dim = dim
+
+    def embed_text(self, text: str) -> List[float]:
+        vec = [0.0] * self.dim
+        tokens = _TOKEN_RE.findall(text.lower())
+        if not tokens:
+            return vec
+        for token in tokens:
+            digest = blake2b(token.encode("utf-8"), digest_size=8).digest()
+            idx = int.from_bytes(digest[:4], "big") % self.dim
+            sign = 1.0 if (digest[4] & 1) == 0 else -1.0
+            vec[idx] += sign
+        return _l2_normalize(vec)
+
+    def embed_many(self, texts: Iterable[str]) -> List[List[float]]:
+        return [self.embed_text(text) for text in texts]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Alias matching the NeuralEmbedder interface."""
+        return self.embed_many(texts)
+
+
+# ===================================================================
+# Factory
+# ===================================================================
+
+def get_embedder(
+    model_name: Optional[str] = None,
+    cache_dir: Optional[Path] = None,
+    device: str = "cpu",
+) -> Union[NeuralEmbedder, HashEmbeddingModel]:
+    """Return the best available embedder.
+
+    * If ``sentence-transformers`` is installed → :class:`NeuralEmbedder`.
+    * Otherwise → :class:`HashEmbeddingModel` (zero-dependency fallback).
+    """
+    try:
+        import sentence_transformers  # noqa: F401
+        return NeuralEmbedder(
+            model_name=model_name or "all-MiniLM-L6-v2",
+            cache_dir=cache_dir,
+            device=device,
+        )
+    except ImportError:
+        logger.warning(
+            "sentence-transformers not installed – "
+            "using hash-based embeddings (no semantic understanding). "
+            "Install with: pip install sentence-transformers"
+        )
+        return HashEmbeddingModel()
+
+
+# ===================================================================
+# Utility
+# ===================================================================
+
+def cosine_similarity(vec_a: List[float], vec_b: List[float]) -> float:
+    """Cosine similarity between two L2-normalised vectors."""
+    if not vec_a or not vec_b or len(vec_a) != len(vec_b):
+        return 0.0
+    return sum(a * b for a, b in zip(vec_a, vec_b))
+
+
+def _l2_normalize(vec: List[float]) -> List[float]:
+    norm = math.sqrt(sum(v * v for v in vec))
+    if norm == 0:
+        return vec
+    return [v / norm for v in vec]

codegraph_cli/graph_export.py

@@ -0,0 +1,144 @@
+"""Graph export helpers for DOT and simple standalone HTML outputs."""
+
+from __future__ import annotations
+
+import html
+import json
+from pathlib import Path
+from typing import Dict, List
+
+from .storage import GraphStore
+
+
+def export_dot(store: GraphStore, output_file: Path, focus: str = "") -> None:
+    nodes = {row["node_id"]: row for row in store.get_nodes()}
+    edges = [dict(e) for e in store.get_edges()]
+
+    selected = _focused_subgraph(nodes, edges, focus)
+
+    lines = ["digraph CodeGraph {"]
+    lines.append("  rankdir=LR;")
+
+    for node_id in selected["nodes"]:
+        if node_id not in nodes:
+            continue
+        node = nodes[node_id]
+        label = f"{node['node_type']}\\n{node['qualname']}"
+        lines.append(f'  "{node_id}" [label="{_esc(label)}"];')
+
+    for edge in selected["edges"]:
+        if edge["src"] not in nodes or edge["dst"] not in nodes:
+            continue
+        lines.append(
+            f'  "{edge["src"]}" -> "{edge["dst"]}" [label="{_esc(edge["edge_type"])}"];'
+        )
+
+    lines.append("}")
+    output_file.write_text("\n".join(lines), encoding="utf-8")
+
+
+def export_html(store: GraphStore, output_file: Path, focus: str = "") -> None:
+    """Export graph to interactive HTML visualization using vis.js."""
+    nodes = {row["node_id"]: row for row in store.get_nodes()}
+    edges = [dict(e) for e in store.get_edges()]
+
+    selected = _focused_subgraph(nodes, edges, focus)
+    graph_payload = {
+        "nodes": [
+            {
+                "id": node_id,
+                "label": f"{nodes[node_id]['node_type']}: {nodes[node_id]['qualname']}",
+                "title": nodes[node_id]["file_path"],
+            }
+            for node_id in selected["nodes"]
+            if node_id in nodes
+        ],
+        "edges": [e for e in selected["edges"] if e["src"] in nodes and e["dst"] in nodes],
+    }
+
+    # Load interactive template
+    template_path = Path(__file__).parent / "templates" / "graph_interactive.html"
+    
+    if template_path.exists():
+        template = template_path.read_text(encoding="utf-8")
+        # Inject graph data
+        doc = template.replace("{{ GRAPH_DATA }}", json.dumps(graph_payload, indent=2))
+    else:
+        # Fallback to basic HTML if template not found
+        doc = _basic_html_export(graph_payload)
+    
+    output_file.write_text(doc, encoding="utf-8")
+
+
+def _basic_html_export(graph_payload: dict) -> str:
+    """Fallback basic HTML export."""
+    return f"""<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>CodeGraph Export</title>
+  <style>
+    body {{ font-family: ui-monospace, SFMono-Regular, Menlo, monospace; margin: 20px; }}
+    #container {{ display: grid; grid-template-columns: 1fr 1fr; gap: 18px; }}
+    .panel {{ border: 1px solid #ddd; border-radius: 8px; padding: 10px; }}
+    ul {{ list-style: none; padding: 0; margin: 0; }}
+    li {{ margin: 4px 0; }}
+  </style>
+</head>
+<body>
+  <h1>CodeGraph Export</h1>
+  <div id="container">
+    <div class="panel">
+      <h2>Nodes</h2>
+      <ul id="nodes"></ul>
+    </div>
+    <div class="panel">
+      <h2>Edges</h2>
+      <ul id="edges"></ul>
+    </div>
+  </div>
+  <script>
+    const graph = {json.dumps(graph_payload)};
+    const nodesEl = document.getElementById('nodes');
+    const edgesEl = document.getElementById('edges');
+    graph.nodes.forEach(n => {{
+      const li = document.createElement('li');
+      li.textContent = `${{n.id}} -> ${{n.label}} (${{n.title}})`;
+      nodesEl.appendChild(li);
+    }});
+    graph.edges.forEach(e => {{
+      const li = document.createElement('li');
+      li.textContent = `${{e.src}} --${{e.edge_type}}--> ${{e.dst}}`;
+      edgesEl.appendChild(li);
+    }});
+  </script>
+</body>
+</html>
+"""
+
+
+def _focused_subgraph(nodes: Dict[str, dict], edges: List[dict], focus: str) -> Dict[str, List]:
+    if not focus:
+        return {"nodes": list(nodes.keys()), "edges": edges}
+
+    focus_ids = {
+        node_id
+        for node_id, node in nodes.items()
+        if focus in node_id or focus in node["name"] or focus in node["qualname"]
+    }
+
+    if not focus_ids:
+        return {"nodes": list(nodes.keys()), "edges": edges}
+
+    edge_subset = [e for e in edges if e["src"] in focus_ids or e["dst"] in focus_ids]
+    node_subset = set(focus_ids)
+    for e in edge_subset:
+        if e["src"] in nodes:
+            node_subset.add(e["src"])
+        if e["dst"] in nodes:
+            node_subset.add(e["dst"])
+    return {"nodes": sorted(node_subset), "edges": edge_subset}
+
+
+def _esc(text: str) -> str:
+    return text.replace('"', '\\"')