entari-plugin-hyw 3.4.2__py3-none-any.whl → 3.5.0rc2__py3-none-any.whl

entari_plugin_hyw/card-ui/src/test_regex.js

@@ -0,0 +1,103 @@
+
+const stripPrefixBeforeH1 = (text) => {
+    const h1Match = text.match(/^#\s+/m)
+    if (h1Match && h1Match.index !== undefined) {
+        return text.substring(h1Match.index)
+    }
+    return text
+}
+
+const dedent = (text) => {
+    const lines = text.split('\n')
+    // Find minimum indentation of non-empty lines
+    let minIndent = Infinity
+    for (const line of lines) {
+        if (line.trim().length === 0) continue
+        const leadingSpace = line.match(/^\s*/)?.[0].length || 0
+        if (leadingSpace < minIndent) minIndent = leadingSpace
+    }
+
+    if (minIndent === Infinity || minIndent === 0) return text
+
+    return lines.map(line => {
+        if (line.trim().length === 0) return ''
+        return line.substring(minIndent)
+    }).join('\n')
+}
+
+const parse = (rawMd) => {
+    if (!rawMd) return []
+
+    const md = stripPrefixBeforeH1(rawMd)
+
+    let content = md.replace(/^#\s+.+$/m, '')
+    content = content.replace(/(?:^|\n)\s*(?:#{1,3}|\*\*)\s*(?:References|Citations|Sources)[\s\S]*$/i, '')
+    content = content.trim()
+
+    const sections = []
+
+    const combinedRegex = /(```[\s\S]*?```|((?:^|\n)\|[^\n]*\|(?:\n\|[^\n]*\|)*)|<summary>[\s\S]*?<\/summary>)/
+
+    let remaining = content
+
+    while (remaining) {
+        const match = remaining.match(combinedRegex)
+        if (!match) {
+            if (remaining.trim()) {
+                sections.push({ type: 'markdown', content: remaining.trim() })
+            }
+            break
+        }
+
+        const index = match.index
+        const matchedStr = match[0]
+        const preText = remaining.substring(0, index)
+
+        if (preText.trim()) {
+            sections.push({ type: 'markdown', content: preText.trim() })
+        }
+
+        const isCode = matchedStr.startsWith('```')
+        const isSummary = matchedStr.startsWith('<summary>')
+        const isTable = !isCode && !isSummary && matchedStr.trim().startsWith('|')
+
+        if (isCode || isTable || isSummary) {
+            let language = ''
+            let content = matchedStr.trim()
+
+            if (isCode) {
+                const match = matchedStr.match(/^```(\w+)/)
+                if (match && match[1]) language = match[1]
+            } else if (isSummary) {
+                content = content.replace(/^<summary>/, '').replace(/<\/summary>$/, '')
+                content = dedent(content)
+            }
+
+            sections.push({
+                type: 'card',
+                title: isCode ? 'Code' : (isSummary ? 'Summary' : 'Table'),
+                content: content,
+                contentType: isCode ? 'code' : (isSummary ? 'summary' : 'table'),
+                language: language
+            })
+        } else {
+            sections.push({ type: 'markdown', content: matchedStr })
+        }
+
+        remaining = remaining.substring(index + matchedStr.length)
+    }
+
+    return sections
+}
+
+const test1 = `
+# Title
+
+<summary>
+    Indented text.
+    It might become code block.
+</summary>
+`
+
+console.log("\n--- Test 2 (After Fix) ---")
+console.log(JSON.stringify(parse(test1), null, 2))

entari_plugin_hyw/card-ui/src/types.ts

@@ -0,0 +1,52 @@
+// Type definitions for render data
+// Python only passes raw data, all processing happens in frontend
+
+export interface Stage {
+    name: string
+    model: string
+    provider: string
+    icon_name?: string  // Icon identifier (e.g., "google", "openai")
+    time: number        // Time in seconds (raw number)
+    cost: number        // Cost in dollars (raw number)
+    references?: Reference[]
+    image_references?: ImageReference[]
+    crawled_pages?: CrawledPage[]
+}
+
+export interface Reference {
+    title: string
+    url: string
+}
+
+export interface ImageReference {
+    title: string
+    url: string
+    thumbnail?: string
+}
+
+export interface CrawledPage {
+    title: string
+    url: string
+}
+
+export interface Stats {
+    total_time?: number
+    vision_duration?: number
+}
+
+export interface Flags {
+    has_vision: boolean
+    has_search: boolean
+}
+
+// Raw data from Python - minimal processing
+export interface RenderData {
+    markdown: string          // Raw markdown content
+    stages: Stage[]
+    references: Reference[]   // All references for citation
+    page_references: Reference[]
+    image_references: ImageReference[]
+    stats: Stats
+    total_time: number
+    theme_color?: string      // Configurable theme color (hex)
+}

entari_plugin_hyw/card-ui/tsconfig.app.json

@@ -0,0 +1,16 @@
+{
+  "extends": "@vue/tsconfig/tsconfig.dom.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "types": ["vite/client"],
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"]
+}

entari_plugin_hyw/card-ui/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

entari_plugin_hyw/card-ui/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

entari_plugin_hyw/card-ui/vite.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import tailwindcss from '@tailwindcss/vite'
+import { viteSingleFile } from 'vite-plugin-singlefile'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    tailwindcss(),
+    viteSingleFile(),
+  ],
+  build: {
+    outDir: '../assets/card-dist',
+    emptyOutDir: true,
+  },
+})

entari_plugin_hyw/{core/history.py → history.py}

@@ -79,13 +79,37 @@ class HistoryManager:
         """Save conversation history to disk"""
         import os
         import time
+        import re
         
         if key not in self._history:
             return
 
         try:
             os.makedirs(save_dir, exist_ok=True)
-            filename = f"{save_dir}/{key}_{int(time.time())}.md"
+            
+            # Extract user's first message (question) for filename
+            user_question = ""
+            for msg in self._history[key]:
+                if msg.get("role") == "user":
+                    content = msg.get("content", "")
+                    # Handle content that might be a list (multimodal)
+                    if isinstance(content, list):
+                        for item in content:
+                            if isinstance(item, dict) and item.get("type") == "text":
+                                user_question = item.get("text", "")
+                                break
+                    else:
+                        user_question = str(content)
+                    break
+            
+            # Clean and truncate question for filename (10 chars)
+            question_part = re.sub(r'[\\/:*?"<>|\n\r\t]', '', user_question)[:10].strip()
+            if not question_part:
+                question_part = "conversation"
+            
+            # Format: YYYYMMDD_HHMMSS_question.md
+            time_str = time.strftime("%Y%m%d_%H%M%S", time.localtime())
+            filename = f"{save_dir}/{time_str}_{question_part}.md"
             
             # Formatter
             timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

entari_plugin_hyw/image_cache.py

@@ -0,0 +1,283 @@
+"""
+Image Caching Module for Pre-downloading Images
+
+This module provides async image pre-download functionality to reduce render time.
+Images are downloaded in the background when search results are obtained,
+and cached as base64 data URLs for instant use during rendering.
+"""
+
+import asyncio
+import base64
+import hashlib
+from typing import Dict, List, Optional, Any
+from loguru import logger
+import httpx
+
+
+
+class ImageCache:
+    """
+    Async image cache that pre-downloads images as base64.
+    
+    Usage:
+        cache = ImageCache()
+        
+        # Start pre-downloading images (non-blocking)
+        cache.start_prefetch(image_urls)
+        
+        # Later, get cached image (blocking if not ready)
+        cached_url = await cache.get_cached(url)  # Returns data:image/... or original URL
+    """
+    
+    def __init__(
+        self, 
+        max_size_kb: int = 500,  # Max image size to cache (KB)
+        timeout: float = 5.0,    # Download timeout per image
+        max_concurrent: int = 6,  # Max concurrent downloads
+    ):
+        self.max_size_bytes = max_size_kb * 1024
+        self.timeout = timeout
+        self.max_concurrent = max_concurrent
+        
+        # Cache storage: url -> base64_data_url or None (if failed)
+        self._cache: Dict[str, Optional[str]] = {}
+        # Pending downloads: url -> asyncio.Task
+        self._pending: Dict[str, asyncio.Task] = {}
+        # Semaphore for concurrent downloads
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+        # Lock for cache access
+        self._lock = asyncio.Lock()
+    
+    def start_prefetch(self, urls: List[str]) -> None:
+        """
+        Start pre-downloading images in the background (non-blocking).
+        
+        Args:
+            urls: List of image URLs to prefetch
+        """
+        if not httpx:
+            logger.warning("ImageCache: httpx not installed, prefetch disabled")
+            return
+            
+        for url in urls:
+            if not url or not url.startswith("http"):
+                continue
+            if url in self._cache or url in self._pending:
+                continue
+            
+            # Create background task
+            task = asyncio.create_task(self._download_image(url))
+            self._pending[url] = task
+    
+    async def _download_image(self, url: str) -> Optional[str]:
+        """
+        Download a single image and convert to base64.
+        
+        Returns:
+            Base64 data URL or None if failed/too large
+        """
+        async with self._semaphore:
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout, follow_redirects=True) as client:
+                    resp = await client.get(url, headers={
+                        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+                    })
+                    resp.raise_for_status()
+                    
+                    # Check content length
+                    content_length = resp.headers.get("content-length")
+                    if content_length and int(content_length) > self.max_size_bytes:
+                        logger.debug(f"ImageCache: Skipping {url} (too large: {content_length} bytes)")
+                        async with self._lock:
+                            self._cache[url] = None
+                            self._pending.pop(url, None)
+                        return None
+                    
+                    # Read content
+                    content = resp.content
+                    if len(content) > self.max_size_bytes:
+                        logger.debug(f"ImageCache: Skipping {url} (content too large: {len(content)} bytes)")
+                        async with self._lock:
+                            self._cache[url] = None
+                            self._pending.pop(url, None)
+                        return None
+                    
+                    # Determine MIME type
+                    content_type = resp.headers.get("content-type", "").lower()
+                    if "jpeg" in content_type or "jpg" in content_type:
+                        mime = "image/jpeg"
+                    elif "png" in content_type:
+                        mime = "image/png"
+                    elif "gif" in content_type:
+                        mime = "image/gif"
+                    elif "webp" in content_type:
+                        mime = "image/webp"
+                    elif "svg" in content_type:
+                        mime = "image/svg+xml"
+                    else:
+                        # Try to infer from URL
+                        url_lower = url.lower()
+                        if ".jpg" in url_lower or ".jpeg" in url_lower:
+                            mime = "image/jpeg"
+                        elif ".png" in url_lower:
+                            mime = "image/png"
+                        elif ".gif" in url_lower:
+                            mime = "image/gif"
+                        elif ".webp" in url_lower:
+                            mime = "image/webp"
+                        elif ".svg" in url_lower:
+                            mime = "image/svg+xml"
+                        else:
+                            mime = "image/jpeg"  # Default fallback
+                    
+                    # Encode to base64
+                    b64 = base64.b64encode(content).decode("utf-8")
+                    data_url = f"data:{mime};base64,{b64}"
+                    
+                    async with self._lock:
+                        self._cache[url] = data_url
+                        self._pending.pop(url, None)
+                    
+                    logger.debug(f"ImageCache: Cached {url} ({len(content)} bytes)")
+                    return data_url
+                    
+            except asyncio.TimeoutError:
+                logger.debug(f"ImageCache: Timeout downloading {url}")
+            except Exception as e:
+                logger.debug(f"ImageCache: Failed to download {url}: {e}")
+            
+            async with self._lock:
+                self._cache[url] = None
+                self._pending.pop(url, None)
+            return None
+    
+    async def get_cached(self, url: str, wait: bool = True, wait_timeout: float = 3.0) -> str:
+        """
+        Get cached image data URL, or original URL if not cached.
+        
+        Args:
+            url: Original image URL
+            wait: If True, wait for pending download to complete
+            wait_timeout: Max time to wait for pending download
+            
+        Returns:
+            Cached data URL or original URL
+        """
+        if not url:
+            return url
+            
+        # Check if already cached
+        async with self._lock:
+            if url in self._cache:
+                cached = self._cache[url]
+                return cached if cached else url  # Return original if cached as None (failed)
+            
+            pending_task = self._pending.get(url)
+        
+        # Wait for pending download if requested
+        if pending_task and wait:
+            try:
+                await asyncio.wait_for(asyncio.shield(pending_task), timeout=wait_timeout)
+                async with self._lock:
+                    cached = self._cache.get(url)
+                    return cached if cached else url
+            except asyncio.TimeoutError:
+                logger.debug(f"ImageCache: Timeout waiting for {url}")
+                return url
+            except Exception:
+                return url
+        
+        return url
+    
+    async def get_all_cached(self, urls: List[str], wait_timeout: float = 3.0) -> Dict[str, str]:
+        """
+        Get cached URLs for multiple images.
+        
+        Args:
+            urls: List of original URLs
+            wait_timeout: Max time to wait for all pending downloads
+            
+        Returns:
+            Dict mapping original URL to cached data URL (or original if not cached)
+        """
+        result = {}
+        
+        # Wait for all pending downloads first
+        pending_tasks = []
+        async with self._lock:
+            for url in urls:
+                if url in self._pending:
+                    pending_tasks.append(self._pending[url])
+        
+        if pending_tasks:
+            try:
+                await asyncio.wait_for(
+                    asyncio.gather(*pending_tasks, return_exceptions=True),
+                    timeout=wait_timeout
+                )
+            except asyncio.TimeoutError:
+                logger.debug(f"ImageCache: Timeout waiting for batch download")
+        
+        # Collect results
+        for url in urls:
+            async with self._lock:
+                cached = self._cache.get(url)
+            result[url] = cached if cached else url
+            
+        return result
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics."""
+        cached_count = sum(1 for v in self._cache.values() if v is not None)
+        failed_count = sum(1 for v in self._cache.values() if v is None)
+        return {
+            "cached": cached_count,
+            "failed": failed_count,
+            "pending": len(self._pending),
+            "total": len(self._cache) + len(self._pending),
+        }
+    
+    def clear(self) -> None:
+        """Clear all cached data."""
+        self._cache.clear()
+        for task in self._pending.values():
+            task.cancel()
+        self._pending.clear()
+
+
+# Global cache instance for reuse across requests
+_global_cache: Optional[ImageCache] = None
+
+
+def get_image_cache() -> ImageCache:
+    """Get or create the global image cache instance."""
+    global _global_cache
+    if _global_cache is None:
+        _global_cache = ImageCache()
+    return _global_cache
+
+
+async def prefetch_images(urls: List[str]) -> None:
+    """
+    Convenience function to start prefetching images.
+    
+    Args:
+        urls: List of image URLs to prefetch
+    """
+    cache = get_image_cache()
+    cache.start_prefetch(urls)
+
+
+async def get_cached_images(urls: List[str], wait_timeout: float = 3.0) -> Dict[str, str]:
+    """
+    Convenience function to get cached images.
+    
+    Args:
+        urls: List of original URLs
+        wait_timeout: Max time to wait
+        
+    Returns:
+        Dict mapping original URL to cached data URL
+    """
+    cache = get_image_cache()
+    return await cache.get_all_cached(urls, wait_timeout=wait_timeout)

entari_plugin_hyw/{utils/misc.py → misc.py}

@@ -25,9 +25,6 @@ def process_onebot_json(data: Dict[str, Any]) -> str:
     return ""
 
 
-
-
-
 async def download_image(url: str) -> bytes:
     """下载图片"""
     try: