utim-cli 1.0.0__py3-none-any.whl

utim_cli/share.py

@@ -0,0 +1,320 @@
+import os
+import json
+import uuid
+import datetime
+import zipfile
+import requests
+from pathlib import Path
+from typing import List, Dict, Tuple, Optional
+
+# Constants
+SHARES_DIR = Path(".utim/shares")
+SHARES_META_FILE = Path(".utim/shares.json")
+
+# Default exclude categories and their descriptions
+EXCLUDE_OPTIONS = [
+    {"key": "node_modules", "name": "node_modules", "desc": "Node.js dependencies"},
+    {"key": ".git", "name": ".git", "desc": "Git repository history"},
+    {"key": "__pycache__", "name": "__pycache__", "desc": "Python bytecode cache"},
+    {"key": "venv", "name": "venv / .venv", "desc": "Python virtual environments"},
+    {"key": "dist", "name": "dist / build", "desc": "Compiled build/distribution folders"},
+    {"key": ".next", "name": ".next / .nuxt", "desc": "Next.js / Nuxt.js dev & build caches"},
+    {"key": "target", "name": "target", "desc": "Rust cargo build artifacts"},
+    {"key": ".env", "name": ".env / configuration", "desc": "Environment secrets and local configs"},
+]
+
+# Expiry options in hours
+EXPIRY_OPTIONS = [
+    {"label": "15 Minutes", "hours": 0.25},
+    {"label": "1 Hour", "hours": 1.0},
+    {"label": "4 Hours", "hours": 4.0},
+    {"label": "24 Hours", "hours": 24.0},
+    {"label": "3 Days", "hours": 72.0},
+    {"label": "7 Days", "hours": 168.0},
+]
+
+class ShareRecord:
+    def __init__(self, id: str, name: str, created_at: str, expires_at: str, link: str, file_path: str, excluded: List[str]):
+        self.id = id
+        self.name = name
+        self.created_at = created_at
+        self.expires_at = expires_at
+        self.link = link
+        self.file_path = file_path
+        self.excluded = excluded
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "created_at": self.created_at,
+            "expires_at": self.expires_at,
+            "link": self.link,
+            "file_path": self.file_path,
+            "excluded": self.excluded
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict):
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            created_at=data["created_at"],
+            expires_at=data["expires_at"],
+            link=data["link"],
+            file_path=data["file_path"],
+            excluded=data.get("excluded", [])
+        )
+
+    def is_expired(self) -> bool:
+        try:
+            exp = datetime.datetime.fromisoformat(self.expires_at)
+            now = datetime.datetime.now(datetime.timezone.utc)
+            return now > exp
+        except Exception:
+            return True
+
+    def time_remaining(self) -> str:
+        if self.is_expired():
+            return "Expired"
+        try:
+            exp = datetime.datetime.fromisoformat(self.expires_at)
+            now = datetime.datetime.now(datetime.timezone.utc)
+            delta = exp - now
+            
+            secs = int(delta.total_seconds())
+            if secs < 60:
+                return f"{secs}s left"
+            mins = secs // 60
+            if mins < 60:
+                return f"{mins}m left"
+            hours = mins // 60
+            if hours < 24:
+                return f"{hours}h {mins % 60}m left"
+            days = hours // 24
+            return f"{days}d {hours % 24}h left"
+        except Exception:
+            return "Unknown"
+
+class ShareManager:
+    def __init__(self, workspace_path: str = "."):
+        self.workspace_path = Path(workspace_path).resolve()
+        self.shares_dir = self.workspace_path / SHARES_DIR
+        self.meta_file = self.workspace_path / SHARES_META_FILE
+        self.shares_dir.mkdir(parents=True, exist_ok=True)
+        self._load_meta()
+
+    def _load_meta(self):
+        self.records: Dict[str, ShareRecord] = {}
+        if self.meta_file.exists():
+            try:
+                with open(self.meta_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    for item in data:
+                        rec = ShareRecord.from_dict(item)
+                        self.records[rec.id] = rec
+            except Exception:
+                # Fallback to empty if corrupted
+                pass
+
+    def _save_meta(self):
+        try:
+            data = [rec.to_dict() for rec in self.records.values()]
+            with open(self.meta_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+        except Exception:
+            pass
+
+    def get_all(self) -> List[ShareRecord]:
+        # Return sorted by created_at descending
+        return sorted(self.records.values(), key=lambda r: r.created_at, reverse=True)
+
+    def search(self, query: str) -> List[ShareRecord]:
+        q = query.lower().strip()
+        all_records = self.get_all()
+        if not q:
+            return all_records
+        
+        filtered = []
+        for r in all_records:
+            if q in r.name.lower() or q in r.id.lower() or q in r.link.lower() or any(q in excl.lower() for excl in r.excluded):
+                filtered.append(r)
+        return filtered
+
+    def delete(self, share_id: str) -> bool:
+        if share_id in self.records:
+            rec = self.records[share_id]
+            # Try to delete the zip file
+            zip_p = Path(rec.file_path)
+            if zip_p.exists():
+                try:
+                    zip_p.unlink()
+                except Exception:
+                    pass
+            
+            # Remove from meta
+            del self.records[share_id]
+            self._save_meta()
+            return True
+        return False
+
+    def create_share(self, exclude_keys: List[str], expiry_hours: float, chat_messages: List[Dict]) -> ShareRecord:
+        share_id = f"share_{uuid.uuid4().hex[:12]}"
+        created_at = datetime.datetime.now(datetime.timezone.utc)
+        expires_at = created_at + datetime.timedelta(hours=expiry_hours)
+
+        # Name of workspace
+        workspace_name = self.workspace_path.name or "workspace"
+        zip_filename = f"{workspace_name}_{share_id}.zip"
+        zip_filepath = self.shares_dir / zip_filename
+
+        # Exclude folders
+        # Resolve folders/names to exclude
+        exclude_names = []
+        for key in exclude_keys:
+            # Map categories to actual folder names to filter
+            if key == "venv":
+                exclude_names.extend(["venv", ".venv", "env", ".env-venv"])
+            elif key == "dist":
+                exclude_names.extend(["dist", "build", "out", "target-distribution"])
+            elif key == ".next":
+                exclude_names.extend([".next", ".nuxt", ".expo"])
+            elif key == ".env":
+                exclude_names.extend([".env", ".env.local", ".env.development", ".env.production"])
+            else:
+                exclude_names.append(key)
+
+        # Generate markdown chat history
+        chat_history_content = self._format_chat_history(chat_messages)
+        
+        # Zip files
+        self._zip_workspace(zip_filepath, exclude_names, chat_history_content)
+
+        # Upload and get link
+        link = self._upload_file(zip_filepath, expiry_hours)
+
+        rec = ShareRecord(
+            id=share_id,
+            name=workspace_name,
+            created_at=created_at.isoformat(),
+            expires_at=expires_at.isoformat(),
+            link=link,
+            file_path=str(zip_filepath),
+            excluded=exclude_keys
+        )
+
+        self.records[share_id] = rec
+        self._save_meta()
+        return rec
+
+    def _format_chat_history(self, messages: List[Dict]) -> str:
+        md = []
+        md.append("# UTIM CLI Chat History\n")
+        md.append(f"Shared Workspace: `{self.workspace_path.name}`\n")
+        md.append(f"Export Date: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+        md.append("---\n\n")
+        
+        for msg in messages:
+            role = msg.get("role", "").capitalize()
+            content = msg.get("content", "")
+            
+            # Safely extract text if content is a list
+            if isinstance(content, list):
+                text = "\n".join(p.get("text", "") for p in content if isinstance(p, dict) and "text" in p)
+            else:
+                text = str(content)
+                
+            if role == "System":
+                md.append(f"### ⚙️ System Prompt\n\n```\n{text}\n```\n\n")
+            elif role == "User":
+                md.append(f"### 👤 User\n\n{text}\n\n")
+            elif role == "Assistant":
+                md.append(f"### 🤖 Assistant\n\n{text}\n\n")
+            elif role == "Tool":
+                name = msg.get("name", "Tool")
+                md.append(f"### 🛠️ Tool: {name}\n\n```\n{text}\n```\n\n")
+            else:
+                md.append(f"### 📝 {role}\n\n{text}\n\n")
+                
+            md.append("---\n\n")
+            
+        return "".join(md)
+
+    def _zip_workspace(self, output_zip_path: Path, exclude_names: List[str], chat_history: str):
+        with zipfile.ZipFile(output_zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            # 1. Add the chat history first at root as chat_history.md
+            zipf.writestr("chat_history.md", chat_history)
+
+            # 2. Walk directory recursively
+            for root, dirs, files in os.walk(self.workspace_path):
+                # Filter directories in-place to prevent os.walk recursion
+                # Skip .utim directory so we don't zip previous zips
+                dirs[:] = [d for d in dirs if d not in exclude_names and d != ".utim"]
+
+                for file in files:
+                    if file in exclude_names or file.endswith(('.pyc', '.pyo', '.pyd')):
+                        continue
+                    
+                    # Also skip if file path directory component is excluded
+                    path_parts = Path(root).relative_to(self.workspace_path).parts
+                    if any(p in exclude_names or p == ".utim" for p in path_parts):
+                        continue
+
+                    full_path = Path(root) / file
+                    # Skip the zip itself
+                    if full_path.resolve() == output_zip_path.resolve():
+                        continue
+
+                    # Safe relative path inside the zip
+                    rel_path = full_path.relative_to(self.workspace_path)
+                    try:
+                        zipf.write(str(full_path), str(rel_path))
+                    except Exception:
+                        pass
+
+    def _upload_file(self, zip_filepath: Path, expiry_hours: float) -> str:
+        # Determine expiry string for file.io
+        if expiry_hours <= 0.25:
+            exp = "15m"
+        elif expiry_hours <= 1.0:
+            exp = "1h"
+        elif expiry_hours <= 4.0:
+            exp = "4h"
+        elif expiry_hours <= 24.0:
+            exp = "1d"
+        elif expiry_hours <= 72.0:
+            exp = "3d"
+        else:
+            exp = "7d"
+
+        # Check UTIM_SERVER_URL env var
+        server_url = os.getenv("UTIM_SERVER_URL", "")
+        if server_url:
+            try:
+                # Try uploading to configured server endpoint
+                url = f"{server_url}/shares/upload"
+                with open(zip_filepath, 'rb') as f:
+                    response = requests.post(url, files={"file": f}, data={"expires": exp}, timeout=30)
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("link"):
+                        return data["link"]
+            except Exception:
+                # Fallback to public file.io if server upload fails
+                pass
+
+        # Fallback public upload using file.io
+        try:
+            url = f"https://file.io/?expires={exp}"
+            with open(zip_filepath, 'rb') as f:
+                response = requests.post(url, files={"file": f}, timeout=30)
+            if response.status_code == 200:
+                data = response.json()
+                if data.get("success") and data.get("link"):
+                    return data["link"]
+        except Exception:
+            pass
+
+        # Fallback to local link if offline or upload fails
+        # Return a custom local URI
+        return f"file:///{zip_filepath.resolve().as_posix()}"