memplex 3.2.0__py3-none-any.whl

memnex/core/extractors/vision_mapper.py

@@ -0,0 +1,131 @@
+"""Map Vision LLM components to L2 Function structures."""
+
+from typing import List, Optional, Dict, Any
+from memnex.models.memory import Function
+from memnex.models.misc import FieldValue
+import re
+
+
+class VisionMapper:
+    """Converts Vision LLM output to L2 Function entities."""
+
+    COMPONENT_TYPE_MAP = {
+        "button": "button",
+        "nav": "navigation",
+        "navbar": "navigation",
+        "input": "input_field",
+        "textfield": "input_field",
+        "card": "card",
+        "kpi": "metric_card",
+        "chart": "chart",
+        "graph": "chart",
+        "table": "table",
+        "form": "form",
+        "modal": "modal",
+        "dialog": "modal",
+        "sidebar": "sidebar",
+        "header": "header",
+        "footer": "footer",
+        "label": "label",
+        "text": "text",
+        "icon": "icon",
+        "image": "image",
+        "link": "link",
+        "menu": "menu",
+        "dropdown": "dropdown",
+        "checkbox": "checkbox",
+        "radio": "radio",
+        "switch": "switch",
+        "slider": "slider",
+        "tab": "tab",
+    }
+
+    def vision_to_functions(
+        self,
+        vision_result: dict,
+        source_id: str = "vision"
+    ) -> List[Function]:
+        """Convert Vision LLM components to L2 Function objects."""
+        components = vision_result.get("components", [])
+        functions = []
+
+        for i, comp in enumerate(components):
+            func = self._component_to_function(comp, i, source_id, vision_result)
+            if func:
+                functions.append(func)
+
+        return functions
+
+    def _component_to_function(
+        self,
+        component: dict,
+        index: int,
+        source_id: str,
+        vision_result: dict
+    ) -> Optional[Function]:
+        """Convert a single Vision component to Function."""
+        comp_type = component.get("type", "unknown")
+        label = component.get("label", "")
+        function_name = component.get("function")
+        data = component.get("data", {})
+
+        if not label and not function_name:
+            return None
+
+        if function_name:
+            name = label if label else function_name
+            normalized = self._normalize_name(function_name)
+            trigger_desc = f"点击 {label} 按钮" if comp_type in ("button", "nav") else f"与 {label} 交互"
+        else:
+            name = label
+            normalized = self._normalize_name(label)
+            trigger_desc = f"查看 {label}"
+
+        action_desc = self._build_action(component)
+
+        func = Function(
+            id=f"vision_{source_id}_{index:03d}",
+            name=name,
+            name_normalized=normalized,
+            source_paragraphs=[source_id],
+            trigger=[FieldValue(desc=trigger_desc)],
+            condition=[],
+            action=[FieldValue(desc=action_desc)],
+            benefit=[],
+            confidence=0.85,
+            attributes={
+                "component_type": self.COMPONENT_TYPE_MAP.get(comp_type, comp_type),
+                "vision_data": data,
+                "layout": vision_result.get("layout"),
+                "page_type": vision_result.get("page_type"),
+            }
+        )
+
+        return func
+
+    def _normalize_name(self, name: str) -> str:
+        """Normalize name to snake_case."""
+        normalized = re.sub(r'[^a-zA-Z0-9一-鿿]', '_', name)
+        normalized = normalized.strip('_').lower()
+        normalized = re.sub(r'_+', '_', normalized)
+        return normalized
+
+    def _build_action(self, component: dict) -> str:
+        """Build action description from component."""
+        comp_type = component.get("type", "")
+        label = component.get("label", "")
+
+        action_map = {
+            "button": f"点击 {label}",
+            "nav": f"导航到 {label}",
+            "navbar": f"导航到 {label}",
+            "input": f"输入 {label}",
+            "textfield": f"输入 {label}",
+            "form": f"提交 {label} 表单",
+            "link": f"跳转 {label}",
+            "menu": f"打开 {label} 菜单",
+            "dropdown": f"选择 {label}",
+            "modal": f"打开 {label} 弹窗",
+        }
+
+        return action_map.get(comp_type, f"与 {label} 交互")

memnex/core/handlers/__init__.py

@@ -0,0 +1,7 @@
+"""Input handlers for various content sources."""
+
+from .clipboard import ClipboardHandler
+from .file_handler import FileHandler
+from .url_handler import URLHandler
+
+__all__ = ["ClipboardHandler", "FileHandler", "URLHandler"]

memnex/core/handlers/clipboard.py

@@ -0,0 +1,40 @@
+"""Handle text paste input."""
+
+from typing import List, Tuple
+
+
+class ClipboardHandler:
+    """Handles pasted text content."""
+
+    def parse(self, content: str) -> List[Tuple[str, str]]:
+        """
+        Parse pasted content.
+
+        Returns:
+            List of (content_type, content) tuples.
+            content_type: "markdown", "text"
+        """
+        if not content or not content.strip():
+            return []
+
+        content = content.strip()
+
+        if self._is_markdown(content):
+            return [("markdown", content)]
+        else:
+            return [("text", content)]
+
+    def _is_markdown(self, content: str) -> bool:
+        """Simple markdown detection."""
+        markdown_indicators = [
+            '#',
+            '```',
+            '- ',
+            '* ',
+            '[ ]',
+            '**',
+            '__',
+            '```'
+        ]
+        return any(content.startswith(ind) or f'\n{ind}' in content
+                   for ind in markdown_indicators)

memnex/core/handlers/file_handler.py

@@ -0,0 +1,62 @@
+"""Handle local file input."""
+
+import os
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+
+class FileHandler:
+    """Handles local file reading."""
+
+    SUPPORTED_EXTENSIONS = {
+        '.md', '.markdown', '.txt',
+        '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.pdf',
+        '.docx',
+    }
+
+    def can_handle(self, path: str) -> bool:
+        """Check if file is supported."""
+        ext = Path(path).suffix.lower()
+        return ext in self.SUPPORTED_EXTENSIONS
+
+    def read(self, path: str) -> Optional[Tuple[str, str]]:
+        """
+        Read file content.
+
+        Returns:
+            (content_type, content) or None if unsupported
+        """
+        if not os.path.exists(path):
+            return None
+
+        ext = Path(path).suffix.lower()
+
+        if ext in ('.md', '.markdown', '.txt'):
+            with open(path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            return ("markdown" if ext in ('.md', '.markdown') else "text", content)
+
+        if ext in ('.png', '.jpg', '.jpeg', '.gif', '.bmp'):
+            return ("image", path)
+
+        if ext == '.pdf':
+            return ("pdf", path)
+
+        if ext == '.docx':
+            return ("docx", path)
+
+        return None
+
+    def list_files(self, directory: str, recursive: bool = False) -> List[str]:
+        """List supported files in directory."""
+        files = []
+        path = Path(directory)
+
+        if recursive:
+            for ext in self.SUPPORTED_EXTENSIONS:
+                files.extend([str(p) for p in path.rglob(f'*{ext}')])
+        else:
+            for ext in self.SUPPORTED_EXTENSIONS:
+                files.extend([str(p) for p in path.glob(f'*{ext}')])
+
+        return files

memnex/core/handlers/url_handler.py

@@ -0,0 +1,132 @@
+"""Handle remote URL input."""
+
+import re
+import tempfile
+import os
+from typing import Optional, Tuple
+from urllib.parse import urlparse
+
+
+class URLHandler:
+    """Handles remote URL input and type resolution."""
+
+    URL_TYPE_PATTERNS = {
+        "pdf": [r"\.pdf$", r"/[^/]+\.pdf", r"\?.*\.pdf"],
+        "markdown": [r"\.md$", r"\.markdown$", r"\.mdown$"],
+        "html": [r"\.html?$", r"\.htm$"],
+        "image": [r"\.(png|jpg|jpeg|gif|bmp|webp)$"],
+        "docx": [r"\.docx$"],
+    }
+
+    DOMAIN_PARSERS = {
+        "github.com": "github",
+        "gist.github.com": "gist",
+        "confluence": "confluence",
+        "notion.so": "notion",
+        "notion.site": "notion",
+    }
+
+    def can_handle(self, path: str) -> bool:
+        """Check if input is a URL."""
+        if not path:
+            return False
+
+        url_pattern = re.compile(
+            r'^https?://'
+            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'
+            r'localhost|'
+            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
+            r'(?::\d+)?'
+            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+
+        return bool(url_pattern.match(path))
+
+    def resolve_type(self, url: str) -> str:
+        """Resolve URL to content type based on extension."""
+        url_lower = url.lower()
+
+        for content_type, patterns in self.URL_TYPE_PATTERNS.items():
+            for pattern in patterns:
+                if re.search(pattern, url_lower):
+                    return content_type
+
+        return "html"
+
+    def get_parser_type(self, url: str) -> str:
+        """Get the appropriate parser type for URL."""
+        parsed = urlparse(url)
+        domain = parsed.netloc.lower()
+
+        for key, parser in self.DOMAIN_PARSERS.items():
+            if key in domain:
+                return parser
+
+        return "generic"
+
+    def extract_filename(self, url: str) -> Optional[str]:
+        """Extract filename from URL path."""
+        parsed = urlparse(url)
+        path = parsed.path
+
+        if "/" in path:
+            filename = path.rsplit("/", 1)[-1]
+            if filename:
+                return filename
+
+        return None
+
+    def fetch(self, url: str) -> Optional[Tuple[str, str]]:
+        """
+        Fetch content from URL.
+
+        Returns:
+            (content_type, content_or_path) or None if fetch failed
+        """
+        import urllib.request
+        import urllib.error
+
+        try:
+            req = urllib.request.Request(
+                url,
+                headers={
+                    'User-Agent': 'Mozilla/5.0 (compatible; Content-Extractor/1.0)'
+                }
+            )
+            with urllib.request.urlopen(req, timeout=30) as response:
+                content_type = response.headers.get('Content-Type', '').lower()
+                data = response.read()
+
+                if 'text' in content_type or 'markdown' in content_type:
+                    text = data.decode('utf-8', errors='replace')
+                    resolved_type = self.resolve_type(url)
+                    return (resolved_type if resolved_type != 'html' else 'text', text)
+
+                if 'image' in content_type or self.resolve_type(url) == 'image':
+                    ext = os.path.splitext(self.extract_filename(url) or 'image.png')[1] or '.png'
+                    temp_file = tempfile.NamedTemporaryFile(suffix=ext, delete=False)
+                    temp_file.write(data)
+                    temp_file.close()
+                    return ("image", temp_file.name)
+
+                if 'pdf' in content_type or self.resolve_type(url) == 'pdf':
+                    temp_file = tempfile.NamedTemporaryFile(suffix='.pdf', delete=False)
+                    temp_file.write(data)
+                    temp_file.close()
+                    return ("pdf", temp_file.name)
+
+                text = data.decode('utf-8', errors='replace')
+                return ("html", text)
+
+        except Exception as e:
+            print(f"Failed to fetch URL {url}: {e}")
+            return None
+
+    def cleanup_temp_file(self, path: str) -> bool:
+        """Delete a temp file if it exists."""
+        try:
+            if path and os.path.exists(path):
+                os.unlink(path)
+                return True
+        except Exception:
+            pass
+        return False

memnex/llm/__init__.py

@@ -0,0 +1,25 @@
+"""MemNex LLM provider layer.
+
+Exports:
+    LLMProvider        -- the protocol all providers must satisfy
+    FallbackChain      -- chain-of-responsibility fallback provider
+    LLMEnhancer        -- LLM enhancement manager
+    LLMPromptSanitizer -- input sanitization for LLM prompts
+    IndirectInjectionGuard -- indirect prompt injection protection
+    create_provider    -- factory function to instantiate providers by name
+"""
+
+from memnex.llm.provider import LLMProvider, create_provider
+from memnex.llm.fallback_chain import FallbackChain
+from memnex.llm.sanitizer import LLMPromptSanitizer
+from memnex.llm.injection_guard import IndirectInjectionGuard
+from memnex.llm.enhancer import LLMEnhancer
+
+__all__ = [
+    "LLMProvider",
+    "FallbackChain",
+    "LLMEnhancer",
+    "LLMPromptSanitizer",
+    "IndirectInjectionGuard",
+    "create_provider",
+]

memnex/llm/enhancer.py

@@ -0,0 +1,226 @@
+"""LLM enhancement manager: coordinates all LLM-augmented pipeline nodes."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import TYPE_CHECKING, List
+
+from memnex.models import (
+    EnhancedQuery,
+    FieldValue,
+    Function,
+    Summary,
+)
+
+if TYPE_CHECKING:
+    from memnex.config import LLMConfig
+    from memnex.llm.provider import LLMProvider
+
+logger = logging.getLogger(__name__)
+
+
+class LLMEnhancer:
+    """Unified LLM enhancement manager.
+
+    Orchestrates all LLM-augmented pipeline nodes with per-feature
+    configuration switches.  When a feature is disabled, a rule-based
+    fallback is used instead.
+
+    Parameters
+    ----------
+    llm_provider:
+        An LLMProvider implementation to delegate calls to.
+    config:
+        LLMConfig controlling which enhancements are active.
+    """
+
+    def __init__(self, llm_provider: LLMProvider, config: LLMConfig) -> None:
+        self.llm = llm_provider
+        self.config = config
+
+    # -- LLM Enhancement 1: Semantic Extraction -------------------------
+
+    async def semantic_extract_trigger(self, paragraph: str) -> List[FieldValue]:
+        """Use LLM to semantically extract trigger conditions from a paragraph."""
+        from memnex.llm.sanitizer import LLMPromptSanitizer
+
+        if not self.config.semantic_extraction:
+            return self._rule_based_extract(paragraph, "trigger")
+
+        prompt = LLMPromptSanitizer.build_structured_prompt(
+            instruction="Extract trigger conditions from the following paragraph, "
+            "focusing on user intent rather than simple keyword matching",
+            user_input=paragraph,
+            output_schema={
+                "triggers": [{"desc": "str", "confidence": "float(0-1)"}]
+            },
+        )
+        result = await self.llm.complete_json(prompt)
+        return [
+            FieldValue(
+                desc=r["desc"],
+                sources=["llm_semantic"],
+                source_method="llm_semantic",
+                weight=r.get("weight", 0.8),
+                observation=r.get("confidence", 1.0),
+                created_at=datetime.utcnow(),
+            )
+            for r in result.get("triggers", [])
+        ]
+
+    # -- LLM Enhancement 2: Query Enhancement ---------------------------
+
+    async def enhance_query(self, query: str) -> EnhancedQuery:
+        """Use LLM to understand and expand a user query."""
+        from memnex.llm.sanitizer import LLMPromptSanitizer
+
+        if not self.config.query_enhancement:
+            return EnhancedQuery(original=query, expanded=[query], intent="search")
+
+        prompt = LLMPromptSanitizer.build_structured_prompt(
+            instruction="Analyze the user query intent. Return intent type, "
+            "expanded queries, and related concepts",
+            user_input=query,
+            output_schema={
+                "intent": "search|understand|compare|relation",
+                "expanded_queries": ["str"],
+                "related_concepts": ["str"],
+            },
+        )
+        result = await self.llm.complete_json(prompt)
+        return EnhancedQuery(
+            original=query,
+            expanded=result.get("expanded_queries", [query]),
+            intent=result.get("intent", "search"),
+        )
+
+    # -- LLM Enhancement 2.5: HyDE --------------------------------------
+
+    async def enhance_query_hyde_text(self, query: str) -> str:
+        """Generate a hypothetical answer text for HyDE embedding.
+
+        On failure, silently returns the original query so the main
+        pipeline is never blocked.
+        """
+        from memnex.llm.sanitizer import LLMPromptSanitizer
+
+        if not self.config.query_enhancement:
+            return query
+
+        prompt = LLMPromptSanitizer.build_structured_prompt(
+            instruction="Assume a memory entry fully answers the user query. "
+            "Describe the core content of that memory in 2-3 sentences",
+            user_input=query,
+            output_schema={"hypothetical_memory": "str"},
+        )
+        try:
+            result = await self.llm.complete_json(prompt)
+            return result.get("hypothetical_memory", query)
+        except Exception:
+            return query
+
+    # -- LLM Enhancement 3: Conflict Resolution -------------------------
+
+    async def resolve_conflict(self, func1: Function, func2: Function) -> dict:
+        """Use LLM to analyze two conflicting Function versions and propose a merge."""
+        from memnex.llm.sanitizer import LLMPromptSanitizer
+
+        if not self.config.conflict_resolution:
+            return self._authority_based_resolve(func1, func2)
+
+        conflict_data = {
+            "v1": {
+                "trigger": [fv.desc for fv in func1.trigger],
+                "condition": [fv.desc for fv in func1.condition],
+            },
+            "v2": {
+                "trigger": [fv.desc for fv in func2.trigger],
+                "condition": [fv.desc for fv in func2.condition],
+            },
+        }
+        prompt = LLMPromptSanitizer.build_structured_prompt(
+            instruction="Analyze two conflicting function versions and decide how to merge",
+            user_input=__import__("json").dumps(conflict_data, ensure_ascii=False),
+            output_schema={
+                "decision": "keep_v1|keep_v2|merge",
+                "reasoning": "str",
+                "merged_function": {},
+            },
+        )
+        result = await self.llm.complete_json(prompt)
+        return self._parse_resolution(result)
+
+    # -- LLM Enhancement 4: Summarization --------------------------------
+
+    async def summarize(self, memories: list) -> Summary:
+        """Generate a summary from a list of MemoryNode objects."""
+        from memnex.llm.sanitizer import LLMPromptSanitizer
+
+        if not self.config.summarization:
+            return Summary(
+                key_points=[m.name for m in memories],
+                patterns=[],
+                changes=[],
+            )
+
+        # Only send structured fields, not raw free text (reduces injection risk)
+        summaries = [
+            f"{m.name}: {', '.join(fv.desc for fv in getattr(m, 'action', []))}"
+            for m in memories
+        ]
+        prompt = LLMPromptSanitizer.build_structured_prompt(
+            instruction="Extract key information from the following memories "
+            "and generate a concise summary",
+            user_input="\n".join(summaries),
+            output_schema={
+                "key_points": ["str"],
+                "patterns": ["str"],
+                "changes": ["str"],
+            },
+        )
+        result = await self.llm.complete_json(prompt)
+        return Summary(
+            key_points=result.get("key_points", []),
+            patterns=result.get("patterns", []),
+            changes=result.get("changes", []),
+        )
+
+    # -- Private helpers -------------------------------------------------
+
+    @staticmethod
+    def _rule_based_extract(paragraph: str, role: str) -> List[FieldValue]:
+        """Trivial rule-based extraction when LLM is disabled."""
+        sentences = [s.strip() for s in paragraph.split(".") if s.strip()]
+        return [
+            FieldValue(
+                desc=s,
+                sources=["rule_based"],
+                source_method="rule_based",
+                weight=0.5,
+            )
+            for s in sentences[:5]
+        ]
+
+    @staticmethod
+    def _authority_based_resolve(func1: Function, func2: Function) -> dict:
+        """Fallback conflict resolution based on source authority."""
+        priority = {"requirement": 4, "meeting": 3, "code": 2, "wiki": 1}
+        p1 = priority.get(
+            func1.source_type.value if func1.source_type else "wiki", 1
+        )
+        p2 = priority.get(
+            func2.source_type.value if func2.source_type else "wiki", 1
+        )
+        if p1 >= p2:
+            return {"decision": "keep_v1", "reasoning": "higher source authority"}
+        return {"decision": "keep_v2", "reasoning": "higher source authority"}
+
+    @staticmethod
+    def _parse_resolution(result: dict) -> dict:
+        """Normalize the LLM conflict resolution response."""
+        return {
+            "decision": result.get("decision", "keep_v1"),
+            "reasoning": result.get("reasoning", ""),
+            "merged_function": result.get("merged_function", {}),
+        }