portacode 1.3.32__py3-none-any.whl → 1.4.11.dev0__py3-none-any.whl

portacode/utils/diff_renderer.py

@@ -0,0 +1,371 @@
+"""Stateless utilities for rendering unified diffs as HTML."""
+
+from __future__ import annotations
+
+import difflib
+import logging
+import os
+import time
+from typing import Dict, List, Optional
+
+try:
+    from pygments import highlight
+    from pygments.formatters import HtmlFormatter
+    from pygments.lexers import get_lexer_for_filename
+    from pygments.util import ClassNotFound
+
+    PYGMENTS_AVAILABLE = True
+except ImportError:
+    PYGMENTS_AVAILABLE = False
+    highlight = None  # type: ignore
+    HtmlFormatter = None  # type: ignore
+    get_lexer_for_filename = None  # type: ignore
+    ClassNotFound = Exception  # type: ignore
+
+logger = logging.getLogger(__name__)
+
+
+def generate_html_diff(
+    original_content: str,
+    modified_content: str,
+    file_path: str,
+) -> Optional[Dict[str, str]]:
+    """Generate unified HTML diff (minimal + full context) for two strings."""
+    # If pygments isn't available we fall back to the simplified renderer
+    if not PYGMENTS_AVAILABLE:
+        return _generate_simple_diff_html(original_content, modified_content, file_path)
+
+    # Basic safety limits to keep rendering responsive
+    max_content_size = 500000  # 500KB
+    max_lines = 5000
+    original_line_count = original_content.count("\n")
+    modified_line_count = modified_content.count("\n")
+    if (
+        len(original_content) > max_content_size
+        or len(modified_content) > max_content_size
+        or max(original_line_count, modified_line_count) > max_lines
+    ):
+        logger.warning("Large file detected for diff generation: %s", file_path)
+        return _generate_simple_diff_html(original_content, modified_content, file_path)
+
+    try:
+        original_lines = original_content.splitlines(keepends=True)
+        modified_lines = modified_content.splitlines(keepends=True)
+
+        start_time = time.time()
+        timeout_seconds = 5
+
+        minimal_diff_lines = list(
+            difflib.unified_diff(
+                original_lines,
+                modified_lines,
+                fromfile=f"a/{os.path.basename(file_path)}",
+                tofile=f"b/{os.path.basename(file_path)}",
+                lineterm="",
+                n=3,
+            )
+        )
+        if time.time() - start_time > timeout_seconds:
+            logger.warning("Diff generation timeout for %s", file_path)
+            return None
+
+        if len(original_lines) + len(modified_lines) < 2000:
+            context_span = len(original_lines) + len(modified_lines)
+            full_diff_lines = list(
+                difflib.unified_diff(
+                    original_lines,
+                    modified_lines,
+                    fromfile=f"a/{os.path.basename(file_path)}",
+                    tofile=f"b/{os.path.basename(file_path)}",
+                    lineterm="",
+                    n=context_span,
+                )
+            )
+        else:
+            full_diff_lines = minimal_diff_lines
+
+        parsed_minimal = parse_unified_diff_simple(minimal_diff_lines)
+        parsed_full = parse_unified_diff_simple(full_diff_lines)
+
+        if time.time() - start_time > timeout_seconds:
+            logger.warning("Diff generation timeout for %s", file_path)
+            return None
+
+        minimal_html = render_diff_html(parsed_minimal, file_path, "minimal")
+        full_html = render_diff_html(parsed_full, file_path, "full")
+        return {"minimal": minimal_html, "full": full_html}
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.error("Error generating HTML diff for %s: %s", file_path, exc)
+        return None
+
+
+def parse_unified_diff_simple(diff_lines: List[str]) -> List[Dict]:
+    """Parse unified diff lines into structured rows (no intraline highlighting)."""
+    parsed: List[Dict] = []
+    old_line_num = 0
+    new_line_num = 0
+
+    for line in diff_lines:
+        if line.startswith("@@"):
+            import re
+
+            match = re.match(r"@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@", line)
+            if match:
+                old_line_num = int(match.group(1)) - 1
+                new_line_num = int(match.group(2)) - 1
+            parsed.append(
+                {
+                    "type": "header",
+                    "content": line,
+                    "old_line_num": "",
+                    "new_line_num": "",
+                }
+            )
+        elif line.startswith("---") or line.startswith("+++"):
+            parsed.append(
+                {
+                    "type": "header",
+                    "content": line,
+                    "old_line_num": "",
+                    "new_line_num": "",
+                }
+            )
+        elif line.startswith("-"):
+            old_line_num += 1
+            parsed.append(
+                {
+                    "type": "delete",
+                    "old_line_num": old_line_num,
+                    "new_line_num": "",
+                    "content": line,
+                }
+            )
+        elif line.startswith("+"):
+            new_line_num += 1
+            parsed.append(
+                {
+                    "type": "add",
+                    "old_line_num": "",
+                    "new_line_num": new_line_num,
+                    "content": line,
+                }
+            )
+        elif line.startswith(" "):
+            old_line_num += 1
+            new_line_num += 1
+            parsed.append(
+                {
+                    "type": "context",
+                    "old_line_num": old_line_num,
+                    "new_line_num": new_line_num,
+                    "content": line,
+                }
+            )
+    return parsed
+
+
+def render_diff_html(parsed_diff: List[Dict], file_path: str, view_mode: str) -> str:
+    """Convert parsed diff entries into styled HTML."""
+    if len(parsed_diff) > 1000:
+        logger.warning("Diff too large, truncating: %s (%s lines)", file_path, len(parsed_diff))
+        parsed_diff = parsed_diff[:1000]
+
+    lexer = _get_pygments_lexer(file_path)
+    highlighted_cache = {}
+    if lexer and PYGMENTS_AVAILABLE:
+        unique_lines = {
+            line_info["content"][1:].rstrip("\n")
+            for line_info in parsed_diff
+            if line_info.get("content") and line_info["content"][0] in "+- "
+        }
+        unique_lines = {line for line in unique_lines if line.strip()}
+        if unique_lines:
+            try:
+                combined = "\n".join(unique_lines)
+                highlighted = highlight(
+                    combined, lexer, HtmlFormatter(nowrap=True, noclasses=False, style="monokai")
+                )
+                split_highlighted = highlighted.split("\n")
+                unique_list = list(unique_lines)
+                for idx, content in enumerate(unique_list):
+                    if idx < len(split_highlighted):
+                        highlighted_cache[content] = split_highlighted[idx]
+            except Exception as exc:
+                logger.debug("Error in batch syntax highlighting: %s", exc)
+                highlighted_cache = {}
+
+    html_parts: List[str] = []
+    html_parts.append(f'<div class="unified-diff-container" data-view-mode="{view_mode}">')
+
+    line_additions = sum(1 for line in parsed_diff if line["type"] == "add")
+    line_deletions = sum(1 for line in parsed_diff if line["type"] == "delete")
+
+    html_parts.append(
+        f"""
+            <div class="diff-stats">
+                <div class="diff-stats-left">
+                    <span class="additions">+{line_additions}</span>
+                    <span class="deletions">-{line_deletions}</span>
+                    <span class="file-path">{os.path.basename(file_path)}</span>
+                </div>
+                <div class="diff-stats-right">
+                    <button class="diff-toggle-btn" data-current-mode="{view_mode}">
+                        <i class="fas fa-eye"></i>
+                        <span class="toggle-text"></span>
+                    </button>
+                </div>
+            </div>
+        """
+    )
+
+    html_parts.append('<div class="diff-content">')
+    html_parts.append('<table class="diff-table">')
+
+    for line_info in parsed_diff:
+        if line_info["type"] == "header":
+            continue
+
+        line_type = line_info["type"]
+        old_line_num = line_info.get("old_line_num", "")
+        new_line_num = line_info.get("new_line_num", "")
+        content = line_info.get("content", "")
+
+        final_content = _escape_html(content)
+        if content and content[0] in "+- ":
+            prefix = content[0] if content[0] in "+-" else " "
+            clean_content = content[1:].rstrip("\n")
+            if clean_content.strip():
+                cached = highlighted_cache.get(clean_content)
+                if cached:
+                    final_content = prefix + cached
+                elif lexer and PYGMENTS_AVAILABLE:
+                    try:
+                        highlighted_line = highlight(
+                            clean_content, lexer, HtmlFormatter(nowrap=True, noclasses=False, style="monokai")
+                        )
+                        final_content = prefix + highlighted_line
+                    except Exception as exc:
+                        logger.debug("Error applying syntax highlighting: %s", exc)
+                        final_content = _escape_html(content)
+
+        row_class = f"diff-line diff-{line_type}"
+        html_parts.append(
+            f"""
+                <tr class="{row_class}">
+                    <td class="line-num old-line-num">{old_line_num}</td>
+                    <td class="line-num new-line-num">{new_line_num}</td>
+                    <td class="line-content">{final_content}</td>
+                </tr>
+            """
+        )
+
+    html_parts.append("</table>")
+    html_parts.append("</div>")
+    html_parts.append("</div>")
+    return "".join(html_parts)
+
+
+def render_simple_diff_html(parsed_diff: List[Dict], file_path: str) -> str:
+    """Generate simplified diff HTML tables (no syntax highlighting)."""
+    html_parts = []
+    html_parts.append('<div class="unified-diff-container" data-view-mode="minimal">')
+
+    line_additions = sum(1 for line in parsed_diff if line["type"] == "add")
+    line_deletions = sum(1 for line in parsed_diff if line["type"] == "delete")
+    html_parts.append(
+        f"""
+            <div class="diff-stats">
+                <div class="diff-stats-left">
+                    <span class="additions">+{line_additions}</span>
+                    <span class="deletions">-{line_deletions}</span>
+                    <span class="file-path">{os.path.basename(file_path)} (Large file - simplified view)</span>
+                </div>
+            </div>
+        """
+    )
+
+    html_parts.append('<div class="diff-content">')
+    html_parts.append('<table class="diff-table">')
+
+    for line_info in parsed_diff:
+        if line_info["type"] == "header":
+            continue
+        row_class = f'diff-line diff-{line_info["type"]}'
+        html_parts.append(
+            f"""
+                <tr class="{row_class}">
+                    <td class="line-num old-line-num">{line_info.get("old_line_num", "")}</td>
+                    <td class="line-num new-line-num">{line_info.get("new_line_num", "")}</td>
+                    <td class="line-content">{_escape_html(line_info.get("content", ""))}</td>
+                </tr>
+            """
+        )
+
+    html_parts.append("</table>")
+    html_parts.append("</div>")
+    html_parts.append("</div>")
+    return "".join(html_parts)
+
+
+def generate_fallback_diff_html(file_path: str) -> str:
+    """Fallback view when diff can't be rendered."""
+    return f"""
+        <div class="unified-diff-container" data-view-mode="minimal">
+            <div class="diff-stats">
+                <div class="diff-stats-left">
+                    <span class="file-path">{os.path.basename(file_path)} (Diff unavailable)</span>
+                </div>
+            </div>
+            <div class="diff-content">
+                <div style="padding: 2rem; text-align: center; color: var(--text-secondary);">
+                    <i class="fas fa-exclamation-triangle" style="font-size: 2rem; margin-bottom: 1rem;"></i>
+                    <p>Diff view unavailable for this file</p>
+                    <p style="font-size: 0.9rem;">File may be too large or binary</p>
+                </div>
+            </div>
+        </div>
+    """
+
+
+def _generate_simple_diff_html(original_content: str, modified_content: str, file_path: str) -> Dict[str, str]:
+    """Render simplified HTML diff for large files or when syntax highlighting is unavailable."""
+    diff_lines = list(
+        difflib.unified_diff(
+            original_content.splitlines(keepends=True),
+            modified_content.splitlines(keepends=True),
+            fromfile=f"a/{os.path.basename(file_path)}",
+            tofile=f"b/{os.path.basename(file_path)}",
+            lineterm="",
+            n=3,
+        )
+    )
+    parsed = parse_unified_diff_simple(diff_lines)
+    if len(parsed) > 500:
+        parsed = parsed[:500]
+        logger.info("Truncated large diff to 500 lines for %s", file_path)
+    html = render_simple_diff_html(parsed, file_path)
+    return {"minimal": html, "full": html}
+
+
+def _get_pygments_lexer(file_path: str):
+    if not PYGMENTS_AVAILABLE or not get_lexer_for_filename:  # type: ignore
+        return None
+    try:
+        return get_lexer_for_filename(file_path)  # type: ignore
+    except ClassNotFound:
+        logger.debug("No Pygments lexer found for file: %s", file_path)
+        return None
+    except Exception as exc:
+        logger.debug("Error getting Pygments lexer for %s: %s", file_path, exc)
+        return None
+
+
+def _escape_html(text: str) -> str:
+    return (
+        text.replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+        .replace("'", "&#x27;")
+    )
+

portacode/utils/ntp_clock.py

@@ -1,151 +1,65 @@
 """
-NTP Clock - Synchronized time source for distributed tracing
-
-Provides NTP-synchronized timestamps for accurate distributed tracing.
-Thread-safe implementation with automatic periodic synchronization.
-
-IMPORTANT: All entities (client, server, device) MUST sync to time.cloudflare.com
-If sync fails, timestamps will be None to indicate sync failure.
+Simple clock offset helper that tracks the difference between the local clock and
+the server time. The device obtains the server time over the existing gateway
+WebSocket and updates the offset based on measured round-trip time.
 """
-import ntplib
 import time
-import threading
-import logging
 from datetime import datetime, timezone
 from typing import Optional
 
-logger = logging.getLogger(__name__)
-
 
 class NTPClock:
-    """Thread-safe NTP-synchronized clock."""
-
-    def __init__(self, ntp_server: str = 'time.cloudflare.com'):
-        """Initialize NTP clock.
-
-        Args:
-            ntp_server: NTP server hostname (default: time.cloudflare.com, hardcoded, no fallback)
-        """
-        self.ntp_server = ntp_server
-        self.offset: Optional[float] = None  # Offset from local clock to NTP time (seconds), None if not synced
-        self.last_sync: Optional[float] = None
-        self.sync_interval = 300  # Re-sync every 5 minutes
-        self._lock = threading.Lock()
-        self._sync_in_progress = False
-        self._client = ntplib.NTPClient()
-        self._sync_attempts = 0
-        self._max_sync_attempts = 3
-
-    def sync(self) -> bool:
-        """Synchronize with NTP server.
-
-        Returns:
-            True if sync successful, False otherwise
-        """
-        if self._sync_in_progress:
-            logger.debug("NTP sync already in progress, skipping")
-            return False
-
-        self._sync_in_progress = True
-
-        try:
-            self._sync_attempts += 1
-            response = self._client.request(self.ntp_server, version=3, timeout=2)
-
-            with self._lock:
-                # Offset is difference between NTP time and local time
-                self.offset = response.offset
-                self.last_sync = time.time()
+    """Clock helper that stores a millisecond offset from the local system clock."""
 
-            logger.info(
-                f"✅ NTP sync successful: offset={self.offset*1000:.2f}ms, "
-                f"latency={response.delay*1000:.2f}ms, server={self.ntp_server}"
-            )
+    def __init__(self):
+        self._offset_ms = 0.0
+        self._last_sync = None
+        self._last_latency_ms = None
+        self._smoothing_weight = 0.2
 
-            self._sync_attempts = 0  # Reset on success
-            return True
+    def now(self) -> float:
+        """Return the current timestamp (seconds since epoch) adjusted by the offset."""
+        return time.time() + (self._offset_ms / 1000.0)
 
-        except Exception as e:
-            logger.warning(f"❌ NTP sync failed (attempt {self._sync_attempts}/{self._max_sync_attempts}): {e}")
+    def now_ms(self) -> int:
+        """Return the current timestamp in milliseconds adjusted by the offset."""
+        return int(time.time() * 1000 + self._offset_ms)
 
-            # If all attempts fail, set offset to None to indicate sync failure
-            if self._sync_attempts >= self._max_sync_attempts:
-                with self._lock:
-                    self.offset = None
-                    self.last_sync = None
-                logger.error(f"⚠️  NTP sync failed after {self._max_sync_attempts} attempts. Timestamps will be None.")
-                self._sync_attempts = 0
-
-            return False
-
-        finally:
-            self._sync_in_progress = False
-
-    def now(self) -> Optional[float]:
-        """Get current NTP-synchronized timestamp (seconds since epoch).
-
-        Returns:
-            Timestamp in seconds (Unix epoch) or None if not synced
-        """
-        with self._lock:
-            if self.offset is None:
-                return None
-            return time.time() + self.offset
-
-    def now_ms(self) -> Optional[int]:
-        """Get current NTP-synchronized timestamp in milliseconds.
-
-        Returns:
-            Timestamp in milliseconds (Unix epoch) or None if not synced
-        """
-        ts = self.now()
-        if ts is None:
-            return None
-        return int(ts * 1000)
-
-    def now_iso(self) -> Optional[str]:
-        """Get current NTP-synchronized timestamp in ISO format.
-
-        Returns:
-            ISO 8601 formatted timestamp with UTC timezone or None if not synced
-        """
-        ts = self.now()
-        if ts is None:
-            return None
-        dt = datetime.fromtimestamp(ts, tz=timezone.utc)
-        return dt.isoformat()
+    def now_iso(self) -> str:
+        """Return the current ISO timestamp adjusted by the offset."""
+        return datetime.fromtimestamp(self.now(), tz=timezone.utc).isoformat()
 
     def get_status(self) -> dict:
-        """Get sync status for debugging.
+        """Return metadata about the last synchronization."""
+        return {
+            'server': 'gateway',
+            'offset_ms': self._offset_ms,
+            'last_sync': datetime.fromtimestamp(self._last_sync, tz=timezone.utc).isoformat() if self._last_sync else None,
+            'last_latency_ms': self._last_latency_ms,
+            'is_synced': self._last_sync is not None,
+        }
+
+    def update_from_server(self, server_time_ms: float, latency_ms: float) -> None:
+        """Update the clock offset using the server timestamp and measured latency."""
+        client_receive_ms = time.time() * 1000
+        half_latency = latency_ms / 2
+        estimated_server_received = client_receive_ms - half_latency
+        new_offset = server_time_ms - estimated_server_received
+        if self._last_sync is not None:
+            self._offset_ms += self._smoothing_weight * (new_offset - self._offset_ms)
+        else:
+            self._offset_ms = new_offset
+        self._last_latency_ms = latency_ms
+        self._last_sync = time.time()
 
-        Returns:
-            Dictionary with sync status information
-        """
-        with self._lock:
-            return {
-                'server': self.ntp_server,
-                'offset_ms': self.offset * 1000 if self.offset is not None else None,
-                'last_sync': datetime.fromtimestamp(self.last_sync, tz=timezone.utc).isoformat() if self.last_sync else None,
-                'time_since_sync_sec': time.time() - self.last_sync if self.last_sync else None,
-                'is_synced': self.offset is not None
-            }
+    def sync(self) -> bool:
+        """Legacy sync stub kept for compatibility; no-op so callers continue to work."""
+        return False
 
     def start_auto_sync(self):
-        """Start automatic periodic synchronization in background thread."""
-        # Initial sync
-        self.sync()
-
-        def _sync_loop():
-            while True:
-                time.sleep(self.sync_interval)
-                logger.info("🔄 Starting periodic NTP sync...")
-                self.sync()
-
-        thread = threading.Thread(target=_sync_loop, daemon=True, name='ntp-sync')
-        thread.start()
-        logger.info(f"Started NTP auto-sync thread (interval: {self.sync_interval}s, server: {self.ntp_server})")
+        """Legacy stub that does nothing now that sync happens via the gateway."""
+        pass
 
 
-# Global instance - auto-starts sync on import
+# Global instance
 ntp_clock = NTPClock()
-ntp_clock.start_auto_sync()