entari-plugin-hyw 2.2.5__py3-none-any.whl → 3.5.0rc6__py3-none-any.whl

entari_plugin_hyw/card-ui/src/style.css

@@ -0,0 +1,29 @@
+@import "tailwindcss";
+@plugin "daisyui";
+@plugin "@tailwindcss/typography";
+
+/* Custom styles */
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+}
+
+/* Premium reading color scheme - applies to all prose elements */
+.prose {
+  color: var(--text-body, #3a3a3c) !important;
+}
+
+.prose h1, .prose h2, .prose h3, .prose h4, .prose h5, .prose h6 {
+  color: var(--text-primary, #2c2c2e) !important;
+}
+
+.prose p, .prose li, .prose td, .prose th {
+  color: var(--text-body, #3a3a3c) !important;
+}
+
+.prose strong, .prose b {
+  color: var(--text-primary, #2c2c2e) !important;
+}
+
+.prose code {
+  color: var(--text-body, #3a3a3c) !important;
+}

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/history.py

@@ -0,0 +1,170 @@
+import random
+import string
+from typing import Dict, List, Any, Optional
+
+class HistoryManager:
+    def __init__(self):
+        self._history: Dict[str, List[Dict[str, Any]]] = {}
+        self._metadata: Dict[str, Dict[str, Any]] = {}
+        self._mapping: Dict[str, str] = {}
+        self._context_latest: Dict[str, str] = {}
+        
+        # New: Short code management
+        self._short_codes: Dict[str, str] = {} # code -> key
+        self._key_to_code: Dict[str, str] = {} # key -> code
+        self._context_history: Dict[str, List[str]] = {} # context_id -> list of keys
+
+    def is_bot_message(self, message_id: str) -> bool:
+        """Check if the message ID belongs to a bot message"""
+        return message_id in self._history
+
+    def generate_short_code(self) -> str:
+        """Generate a unique 4-digit hex code"""
+        while True:
+            code = ''.join(random.choices(string.hexdigits.lower(), k=4))
+            if code not in self._short_codes:
+                return code
+
+    def get_conversation_id(self, message_id: str) -> Optional[str]:
+        return self._mapping.get(message_id)
+        
+    def get_key_by_code(self, code: str) -> Optional[str]:
+        return self._short_codes.get(code.lower())
+        
+    def get_code_by_key(self, key: str) -> Optional[str]:
+        return self._key_to_code.get(key)
+
+    def get_history(self, key: str) -> List[Dict[str, Any]]:
+        return self._history.get(key, [])
+
+    def get_metadata(self, key: str) -> Dict[str, Any]:
+        return self._metadata.get(key, {})
+        
+    def get_latest_from_context(self, context_id: str) -> Optional[str]:
+        return self._context_latest.get(context_id)
+        
+    def list_by_context(self, context_id: str, limit: int = 10) -> List[str]:
+        """Return list of keys for a context, most recent first"""
+        keys = self._context_history.get(context_id, [])
+        return keys[-limit:][::-1]
+
+    def remember(self, message_id: Optional[str], history: List[Dict[str, Any]], related_ids: List[str], metadata: Optional[Dict[str, Any]] = None, context_id: Optional[str] = None, code: Optional[str] = None):
+        if not message_id:
+            return
+            
+        key = message_id
+        self._history[key] = history
+        if metadata:
+            self._metadata[key] = metadata
+            
+        self._mapping[key] = key
+        for rid in related_ids:
+            if rid:
+                self._mapping[rid] = key
+                
+        # Generate or use provided short code
+        if key not in self._key_to_code:
+            if not code:
+                code = self.generate_short_code()
+            self._short_codes[code] = key
+            self._key_to_code[key] = code
+            
+        if context_id:
+            self._context_latest[context_id] = key
+            if context_id not in self._context_history:
+                self._context_history[context_id] = []
+            self._context_history[context_id].append(key)
+
+    def save_to_disk(self, key: str, save_dir: str = "data/conversations"):
+        """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)
+            
+            # 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())
+            meta = self._metadata.get(key, {})
+            model_name = meta.get("model", "unknown")
+            code = self._key_to_code.get(key, "N/A")
+            
+            md_content = f"# Conversation Log: {key}\n\n"
+            md_content += f"**Time**: {timestamp}\n"
+            md_content += f"**Code**: {code}\n"
+            md_content += f"**Model**: {model_name}\n"
+            md_content += f"**Metadata**: {meta}\n\n"
+
+            trace_md = meta.get("trace_markdown") if isinstance(meta, dict) else None
+            if trace_md:
+                md_content += "## Trace\n\n"
+                md_content += f"{trace_md}\n\n"
+
+            md_content += "## History\n\n"
+            
+            for msg in self._history[key]:
+                role = msg.get("role", "unknown").upper()
+                content = msg.get("content", "")
+                
+                md_content += f"### {role}\n\n"
+                
+                tool_calls = msg.get("tool_calls")
+                if tool_calls:
+                     import json
+                     try:
+                         tc_str = json.dumps(tool_calls, ensure_ascii=False, indent=2)
+                     except:
+                         tc_str = str(tool_calls)
+                     md_content += f"**Tool Calls**:\n```json\n{tc_str}\n```\n\n"
+                
+                # Special handling for tool outputs or complex content
+                if role == "TOOL":
+                    # Try to pretty print if it's JSON
+                    try:
+                        import json
+                        # Content might be a JSON string already
+                        parsed_content = json.loads(content)
+                        pretty_content = json.dumps(parsed_content, ensure_ascii=False, indent=2)
+                        md_content += f"**Output**:\n```json\n{pretty_content}\n```\n\n"
+                    except:
+                        md_content += f"**Output**:\n```text\n{content}\n```\n\n"
+                else:
+                    if content:
+                        md_content += f"{content}\n\n"
+                
+                md_content += "---\n\n"
+            
+            with open(filename, "w", encoding="utf-8") as f:
+                f.write(md_content)
+                
+        except Exception as e:
+            # We can't log easily here without importing logger, but it's fine
+            print(f"Failed to save conversation: {e}")