differix 0.1.0a1__py3-none-any.whl

tools/asset_manager.py

@@ -0,0 +1,115 @@
+import os
+import re
+import httpx
+from ipaddress import ip_address
+from typing import Dict, List, Optional
+from urllib.parse import urlparse
+
+class AssetManager:
+    """Manages downloading and indexing web assets with security checks."""
+    
+    EXTENSION_MAP = {
+        "image": [".png", ".jpg", ".jpeg", ".webp", ".svg"],
+        "shader": [".glsl", ".frag", ".vert"],
+        "html": [".html"],
+        "3d": [".glb", ".gltf"]
+    }
+    
+    MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+    
+    def __init__(self, project_dir: str):
+        self.project_dir = os.path.abspath(project_dir)
+        self.assets_dir = os.path.join(self.project_dir, ".differix", "assets")
+        os.makedirs(self.assets_dir, exist_ok=True)
+        
+    def _validate_extension(self, filename: str, asset_type: str) -> bool:
+        """Check if file extension matches allowed types for the asset type."""
+        ext = os.path.splitext(filename)[1].lower()
+        return ext in self.EXTENSION_MAP.get(asset_type, [])
+    
+    def _is_private_ip(self, host: str) -> bool:
+        """Check if host resolves to a private IP address."""
+        try:
+            ip = ip_address(host)
+            return ip.is_private or ip.is_loopback
+        except ValueError:
+            return False
+    
+    def _validate_url(self, url: str) -> bool:
+        """Validate URL security - reject private IPs and invalid schemes."""
+        parsed = urlparse(url)
+        if parsed.scheme not in ["http", "https"]:
+            return False
+        if self._is_private_ip(parsed.hostname):
+            return False
+        return True
+    
+    def download_asset(self, url: str, asset_type: str, filename: str) -> str:
+        """Download an asset with security checks and save to assets directory.
+        
+        Args:
+            url: Source URL to download from (must pass SSRF checks)
+            asset_type: Type of asset (image/shader/html/3d)
+            filename: Target filename (must have correct extension for type)
+            
+        Returns:
+            Absolute path to saved asset
+            
+        Raises:
+            ValueError: For security violations, invalid types, or download failures
+        """
+        if not self._validate_url(url):
+            raise ValueError("Invalid or insecure URL")
+            
+        if not self._validate_extension(filename, asset_type):
+            raise ValueError(f"Invalid extension for asset type '{asset_type}'")
+            
+        # Sanitize filename to prevent path traversal
+        filename = os.path.basename(filename)
+        if not filename or filename.startswith('.'):
+            raise ValueError("Invalid filename")
+            
+        target_dir = os.path.join(self.assets_dir, asset_type)
+        os.makedirs(target_dir, exist_ok=True)
+        target_path = os.path.join(target_dir, filename)
+        
+        with httpx.Client(timeout=15.0, follow_redirects=True) as client:
+            try:
+                with client.stream("GET", url) as response:
+                    # Recheck SSRF after following redirects
+                    final_url = str(response.url)
+                    parsed = urlparse(final_url)
+                    if self._is_private_ip(parsed.hostname):
+                        raise ValueError("Redirect leads to private IP - SSRF blocked")
+                        
+                    if response.status_code != 200:
+                        raise ValueError(f"Failed to download asset: HTTP {response.status_code}")
+                        
+                    # Stream download with size cap
+                    total_bytes = 0
+                    chunks = []
+                    for chunk in response.iter_bytes():
+                        total_bytes += len(chunk)
+                        if total_bytes > self.MAX_FILE_SIZE:
+                            raise ValueError(f"File exceeds {self.MAX_FILE_SIZE//(1024*1024)}MB limit")
+                        chunks.append(chunk)
+                        
+                    content = b''.join(chunks)
+                    
+                    # Verify content type matches asset type
+                    content_type = response.headers.get('content-type', '')
+                    if asset_type == 'image' and not content_type.startswith('image/'):
+                        raise ValueError(f"Expected image content type, got {content_type}")
+                    elif asset_type == '3d' and not any(x in content_type for x in ['model/gltf', 'model/gltf-binary']):
+                        raise ValueError(f"Expected 3D model content type, got {content_type}")
+                        
+                    # Write file atomically
+                    temp_path = target_path + '.tmp'
+                    with open(temp_path, 'wb') as f:
+                        f.write(content)
+                    os.replace(temp_path, target_path)
+                    
+            except httpx.RequestError as e:
+                raise ValueError(f"Download failed: {str(e)}")
+                
+        return os.path.abspath(target_path)

tools/atomic_changeset.py

@@ -0,0 +1,264 @@
+"""
+tools/atomic_changeset.py
+--------------------------
+Atomic multi-file change sets for the VegeX editor pipeline.
+
+Root problem this solves: the RSI crash you hit was caused by multi-file
+edits applied non-atomically — file #1 written, file #3 fails sandbox
+validation, repo left in a half-edited state. The editor then re-reads the
+half-applied tree and hallucinates a fix.
+
+This module makes N-file edits behave as either fully-applied or
+fully-rolled-back. On POSIX we can't rename N files in a single syscall,
+but we can:
+  1. Stage all content to .vegex/staging/<uuid>/
+  2. Snapshot backups of every file to be touched
+  3. Apply replacements one by one
+  4. On any failure, restore from the backups
+
+That gives "best-effort atomicity" — the window between rename #1 and
+rename #N is microseconds, no I/O, no LLM calls. Not bulletproof against
+SIGKILL at the exact wrong moment, but eliminates the failure mode that
+actually hurt.
+"""
+
+from __future__ import annotations
+
+import errno
+import logging
+import os
+import shutil
+import tempfile
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ChangeSetError(Exception):
+    """Raised when a change set cannot be applied."""
+
+
+@dataclass
+class ChangeOp:
+    """A single file operation inside a ChangeSet."""
+
+    kind: str  # "write" | "delete"
+    path: str  # relative to project_root, forward slashes
+    content: Optional[str] = None  # required for kind="write"
+
+    def __post_init__(self) -> None:
+        if self.kind not in ("write", "delete"):
+            raise ValueError(f"Invalid kind: {self.kind!r}")
+        if self.kind == "write" and self.content is None:
+            raise ValueError(f"ChangeOp write requires content (path={self.path!r})")
+        if not self.path or self.path.startswith("/") or ".." in Path(self.path).parts:
+            raise ValueError(f"Path must be project-relative, no traversal: {self.path!r}")
+
+
+@dataclass
+class ApplyReport:
+    ok: bool = False
+    applied: List[str] = field(default_factory=list)
+    rolled_back: List[str] = field(default_factory=list)
+    error: Optional[str] = None
+    elapsed_ms: float = 0.0
+
+    def as_dict(self) -> Dict:
+        return {
+            "ok": self.ok,
+            "applied": list(self.applied),
+            "rolled_back": list(self.rolled_back),
+            "error": self.error,
+            "elapsed_ms": round(self.elapsed_ms, 3),
+        }
+
+
+class ChangeSet:
+    """A list of file operations applied atomically (best-effort)."""
+
+    def __init__(self, ops: Optional[Iterable[ChangeOp]] = None) -> None:
+        self.ops: List[ChangeOp] = list(ops or [])
+
+    def add_write(self, path: str, content: str) -> "ChangeSet":
+        self.ops.append(ChangeOp(kind="write", path=path, content=content))
+        return self
+
+    def add_delete(self, path: str) -> "ChangeSet":
+        self.ops.append(ChangeOp(kind="delete", path=path))
+        return self
+
+    def __bool__(self) -> bool:
+        return bool(self.ops)
+
+    def __len__(self) -> int:
+        return len(self.ops)
+
+    # ------------------------------------------------------------------ #
+    # Pre-flight
+    # ------------------------------------------------------------------ #
+    def validate(self, project_root: str) -> None:
+        """
+        Raise ChangeSetError if any op violates invariants:
+          - path escapes project_root
+          - duplicate path within the set
+          - write content exceeds size cap (2 MB default)
+        """
+        root = Path(project_root).resolve()
+        seen: set = set()
+        for op in self.ops:
+            target = (root / op.path).resolve()
+            try:
+                target.relative_to(root)
+            except ValueError:
+                raise ChangeSetError(
+                    f"Path {op.path!r} escapes project root {root}"
+                )
+            if op.path in seen:
+                raise ChangeSetError(f"Duplicate path in change set: {op.path!r}")
+            seen.add(op.path)
+            if op.kind == "write" and op.content is not None and len(op.content) > 2_000_000:
+                raise ChangeSetError(
+                    f"Write content for {op.path!r} exceeds 2MB cap"
+                )
+
+    # ------------------------------------------------------------------ #
+    # Dry run — returns what the tree would look like post-apply
+    # ------------------------------------------------------------------ #
+    def dry_apply(self, project_root: str) -> Dict[str, str]:
+        """
+        Return {path: hypothetical_content} for every file the set touches.
+        Used by the contract validator to check the *intended* post-apply
+        state without writing anything to disk.
+        """
+        root = Path(project_root).resolve()
+        result: Dict[str, str] = {}
+        for op in self.ops:
+            if op.kind == "write":
+                result[op.path] = op.content or ""
+            else:  # delete
+                result[op.path] = ""  # validators treat empty file as no-op
+        return result
+
+    # ------------------------------------------------------------------ #
+    # Apply
+    # ------------------------------------------------------------------ #
+    def apply(self, project_root: str) -> ApplyReport:
+        """Apply all ops. On any failure, rollback previously applied ops."""
+        t0 = time.perf_counter()
+        report = ApplyReport()
+
+        try:
+            self.validate(project_root)
+        except ChangeSetError as exc:
+            report.error = f"Pre-flight failed: {exc}"
+            report.elapsed_ms = (time.perf_counter() - t0) * 1000.0
+            return report
+
+        if not self.ops:
+            report.ok = True
+            report.elapsed_ms = (time.perf_counter() - t0) * 1000.0
+            return report
+
+        root = Path(project_root).resolve()
+        staging_dir = root / ".vegex" / "staging" / uuid.uuid4().hex
+        staging_dir.mkdir(parents=True, exist_ok=True)
+
+        # back up existing content for every target path
+        backups: Dict[str, Optional[str]] = {}
+        try:
+            for op in self.ops:
+                target = root / op.path
+                if target.exists() and target.is_file():
+                    try:
+                        backups[op.path] = target.read_text(encoding="utf-8")
+                    except Exception as exc:
+                        raise ChangeSetError(
+                            f"Cannot read existing {op.path!r} for backup: {exc}"
+                        )
+                else:
+                    backups[op.path] = None
+        except ChangeSetError as exc:
+            report.error = str(exc)
+            _safe_rmtree(staging_dir)
+            report.elapsed_ms = (time.perf_counter() - t0) * 1000.0
+            return report
+
+        # stage all new content to disk first
+        staged_paths: Dict[str, Path] = {}
+        try:
+            for op in self.ops:
+                if op.kind != "write":
+                    continue
+                stage_target = staging_dir / op.path
+                stage_target.parent.mkdir(parents=True, exist_ok=True)
+                stage_target.write_text(op.content or "", encoding="utf-8")
+                staged_paths[op.path] = stage_target
+        except Exception as exc:
+            report.error = f"Staging failed: {exc}"
+            _safe_rmtree(staging_dir)
+            report.elapsed_ms = (time.perf_counter() - t0) * 1000.0
+            return report
+
+        # now do the renames in rapid succession
+        applied: List[str] = []
+        try:
+            for op in self.ops:
+                target = root / op.path
+                if op.kind == "write":
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    os.replace(staged_paths[op.path], target)
+                    applied.append(op.path)
+                else:  # delete
+                    try:
+                        target.unlink()
+                    except FileNotFoundError:
+                        pass
+                    applied.append(op.path)
+        except Exception as exc:
+            # Roll back every file we've already touched
+            rolled_back: List[str] = []
+            for path in applied:
+                backup = backups.get(path)
+                try:
+                    target = root / path
+                    if backup is None:
+                        # didn't exist before → delete what we wrote
+                        try:
+                            target.unlink()
+                        except FileNotFoundError:
+                            pass
+                    else:
+                        target.parent.mkdir(parents=True, exist_ok=True)
+                        target.write_text(backup, encoding="utf-8")
+                    rolled_back.append(path)
+                except Exception as rb_exc:
+                    logger.error("Rollback failed for %s: %s", path, rb_exc)
+
+            report.ok = False
+            report.applied = applied
+            report.rolled_back = rolled_back
+            report.error = f"Apply failed after {len(applied)} ops: {exc}"
+            _safe_rmtree(staging_dir)
+            report.elapsed_ms = (time.perf_counter() - t0) * 1000.0
+            return report
+
+        _safe_rmtree(staging_dir)
+        report.ok = True
+        report.applied = applied
+        report.elapsed_ms = (time.perf_counter() - t0) * 1000.0
+        return report
+
+
+def _safe_rmtree(path: Path) -> None:
+    try:
+        if path.exists():
+            shutil.rmtree(path, ignore_errors=True)
+    except Exception:
+        pass
+
+
+__all__ = ["ChangeOp", "ChangeSet", "ChangeSetError", "ApplyReport"]

tools/backup_manager.py

@@ -0,0 +1,122 @@
+import git
+import os
+from datetime import datetime
+from pathlib import Path
+
+REPO_PATH = '.'
+IGNORE_PATTERNS = [
+    '.env',
+    '*.log',
+    'pycache/',
+    '*.tmp',
+]
+
+def get_repo(path_or_repo=None):
+    """Repo initialisation with path safety check."""
+    target = path_or_repo or REPO_PATH
+    if isinstance(target, git.Repo):
+        return target
+    try:
+        return git.Repo(target)
+    except git.exc.InvalidGitRepositoryError:
+        print(f"Error: path '{target}' is not a valid git repository.")
+        print("Run 'git init' inside target project folder.")
+        return None
+
+def should_ignore(file_path):
+    """Checking whether file is ignored"""
+    file_name = os.path.basename(file_path)
+    for pattern in IGNORE_PATTERNS:
+        if pattern.startswith('*'):
+            if file_name.endswith(pattern[1:]):
+                return True
+        elif pattern.endswith('/'):
+            if pattern[:-1] in file_path:
+                return True
+        else:
+            if file_name == pattern:
+                return True
+    return False
+
+def make_auto_commit(repo_or_path, agent_name="system", comment=""):
+    """Creating commits with file filtration and error processing:"""
+    repo = get_repo(repo_or_path)
+    if not repo:
+        return
+    try:
+        changed_files = [item.a_path for item in repo.index.diff(None)]
+        untracked_files = repo.untracked_files
+        all_candidates = changed_files + untracked_files
+
+        files_to_add = [f for f in all_candidates if not should_ignore(f)]
+
+        if not files_to_add:
+            if not repo.is_dirty() and not untracked_files:
+                print("No updates")
+                return
+            else:
+                print("All updated files are ignored.")
+                return
+
+        repo.git.add(files_to_add)
+
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        message = f"Auto-save [{agent_name}]: {timestamp}"
+        if comment:
+            message += f" — {comment[:80]}"
+
+        try:
+            commit = repo.index.commit(message)
+            print(f"Commit created: {message} (SHA: {commit.hexsha[:7]})")
+        except git.exc.GitCommandError as e:
+            print(f"Commit error: {e}")
+            return
+
+    except Exception as e:
+        print(f"Fatal error while auto-saving: {e}")
+
+def safe_rollback(repo_or_path, target_hash):
+    """Safe rollback to target commit."""
+    repo = get_repo(repo_or_path)
+    if not repo:
+        return
+    branch_name = f"rollback-to-{target_hash[:7]}"
+    try:
+        commit = repo.commit(target_hash)
+        new_branch = repo.create_head(branch_name, commit)
+        repo.heads[branch_name].checkout()
+        print(f"Rollbacked successfully: '{branch_name}'.")
+    except git.exc.GitError as e:
+        print(f"Git error occurred: {e}")
+
+def show_all_commits(repo_or_path, limit=15):
+    """Display git commit list."""
+    repo = get_repo(repo_or_path)
+    if not repo:
+        return []
+    try:
+        commits = list(repo.iter_commits())
+        if limit is not None:
+            commits = commits[:limit]
+
+        print(f"\n--- Git Commits ({len(commits)}) ---")
+        for i, c in enumerate(commits):
+            short = c.hexsha[:7]
+            msg = c.message.strip().split('\n')[0][:70]
+            date = c.committed_datetime.strftime("%Y-%m-%d %H:%M")
+            print(f"{i:3}. {short} | {date} | {msg}")
+        return commits
+    except Exception as e:
+        print(f"Error reading commits: {e}")
+        return []
+
+def create_success_tag(repo_or_path):
+    repo = get_repo(repo_or_path)
+    if not repo:
+        return
+    try:
+        tag_name = f"success-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+        repo.create_tag(tag_name)
+        print(f"Created success tag: {tag_name}")
+    except Exception as e:
+        print(f"Cannot create tag: {e}")