aiforge-engine 0.0.1__py3-none-any.whl

aiforge/__init__.py

@@ -0,0 +1,64 @@
+# 核心模块导入
+from .core.engine import AIForgeEngine
+from .core.task.manager import AIForgeTaskManager
+from .core.task.task import AIForgeTask
+from .execution.result_processor import AIForgeResultProcessor
+
+# LLM模块导入
+from .llm.llm_client import AIForgeLLMClient, AIForgeOllamaClient
+from .llm.llm_manager import AIForgeLLMManager
+
+# 执行引擎导入
+from .execution.engine import AIForgeExecutionEngine
+
+# 配置管理导入
+from .config.config import AIForgeConfig
+
+# 数据获取相关导入
+from .templates.template_manager import TemplateManager
+from .strategies.search_template_strategy import (
+    StandardTemplateStrategy,
+    TemplateGenerationStrategy,
+)
+from .strategies.semantic_field_strategy import SemanticFieldStrategy, FieldProcessorManager
+
+# 其他相关导入
+from .execution.result_formatter import AIForgeResultFormatter
+from .execution.code_blocks import CodeBlockManager, CodeBlock
+from .core.prompt import AIForgePrompt
+from .cli.wizard import create_config_wizard
+from .cache.semantic_cache import EnhancedStandardizedCache
+
+# 指令分析导入
+from .instruction.analyzer import AIForgeInstructionAnalyzer
+
+__all__ = [
+    # 核心组件
+    "AIForgeEngine",
+    "AIForgeTaskManager",
+    "AIForgeTask",
+    "AIForgeResultProcessor",
+    "AIForgeConfig",
+    # LLM组件
+    "AIForgeLLMClient",
+    "AIForgeOllamaClient",
+    "AIForgeLLMManager",
+    # 执行组件
+    "AIForgeExecutionEngine",
+    "EnhancedStandardizedCache",
+    # 数据获取组件
+    "TemplateManager",
+    "StandardTemplateStrategy",
+    "TemplateGenerationStrategy",
+    "SemanticFieldStrategy",
+    "FieldProcessorManager",
+    "AIForgeInstructionAnalyzer",
+    # 工具组件
+    "create_config_wizard",
+    "AIForgeResultFormatter",
+    "CodeBlockManager",
+    "CodeBlock",
+    "AIForgePrompt",
+]
+
+__version__ = "0.0.1"

aiforge/adapters/__init__.py

@@ -0,0 +1,5 @@
+from .output.rule_based_adapter import RuleBasedAdapter
+from .output.ui_type_recommender import UITypeRecommender
+from .output.task_type_detector import TaskTypeDetector
+
+__all__ = ["RuleBasedAdapter", "UITypeRecommender", "TaskTypeDetector"]

aiforge/adapters/input/cli_input_adapter.py

@@ -0,0 +1,45 @@
+from typing import Any
+from .input_adapter import InputAdapter, InputSource, InputContext, StandardizedInput
+
+
+class CLIInputAdapter(InputAdapter):
+    """CLI输入适配器"""
+
+    def can_handle(self, raw_input: Any, source: InputSource) -> bool:
+        return source == InputSource.CLI and isinstance(raw_input, (str, dict))
+
+    def adapt(self, raw_input: Any, context: InputContext) -> StandardizedInput:
+        """适配CLI输入"""
+        if isinstance(raw_input, str):
+            # 简单字符串指令
+            instruction = raw_input
+            metadata = {"input_type": "simple_command"}
+        elif isinstance(raw_input, dict):
+            # 结构化CLI参数
+            instruction = raw_input.get("instruction", "")
+            metadata = {
+                "input_type": "structured_command",
+                "args": raw_input.get("args", {}),
+                "flags": raw_input.get("flags", {}),
+                "options": raw_input.get("options", {}),
+            }
+        else:
+            raise ValueError(f"Unsupported CLI input type: {type(raw_input)}")
+
+        # CLI特定的元数据
+        metadata.update(
+            {
+                "terminal_width": context.device_info.get("terminal_width", 80),
+                "supports_color": context.device_info.get("supports_color", True),
+                "shell_type": context.device_info.get("shell", "bash"),
+            }
+        )
+
+        return StandardizedInput(instruction=instruction, context=context, metadata=metadata)
+
+    def validate(self, standardized_input: StandardizedInput) -> bool:
+        """验证CLI输入"""
+        return (
+            bool(standardized_input.instruction.strip())
+            and len(standardized_input.instruction) <= 10000  # CLI输入长度限制
+        )

aiforge/adapters/input/gui_input_adapter.py

@@ -0,0 +1,40 @@
+from typing import Any
+
+from .input_adapter import InputAdapter, InputSource, InputContext, StandardizedInput
+
+
+class GUIInputAdapter(InputAdapter):
+    """GUI输入适配器"""
+
+    def can_handle(self, raw_input: Any, source: InputSource) -> bool:
+        return source == InputSource.GUI and isinstance(raw_input, dict)
+
+    def adapt(self, raw_input: Any, context: InputContext) -> StandardizedInput:
+        """适配GUI输入"""
+        instruction = raw_input.get("text", "")
+
+        # GUI特定的元数据
+        metadata = {
+            "input_type": "gui_text",
+            "widget_id": raw_input.get("widget_id"),
+            "cursor_position": raw_input.get("cursor_position", 0),
+            "selection": raw_input.get("selection", {}),
+            "input_method": raw_input.get("input_method", "keyboard"),
+            "screen_size": context.device_info.get("screen_size", {}),
+            "theme": context.preferences.get("theme", "default"),
+        }
+
+        # 处理附件（如果有）
+        attachments = {}
+        if "files" in raw_input:
+            attachments["files"] = raw_input["files"]
+        if "images" in raw_input:
+            attachments["images"] = raw_input["images"]
+
+        return StandardizedInput(
+            instruction=instruction, context=context, metadata=metadata, attachments=attachments
+        )
+
+    def validate(self, standardized_input: StandardizedInput) -> bool:
+        """验证GUI输入"""
+        return bool(standardized_input.instruction.strip())

aiforge/adapters/input/input_adapter.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+from enum import Enum
+
+
+class InputSource(Enum):
+    """输入源类型"""
+
+    CLI = "cli"
+    GUI = "gui"
+    WEB = "web"
+    MOBILE = "mobile"
+    API = "api"
+    VOICE = "voice"
+
+
+class InputContext:
+    """输入上下文信息"""
+
+    def __init__(
+        self,
+        source: InputSource,
+        user_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        device_info: Optional[Dict[str, Any]] = None,
+        preferences: Optional[Dict[str, Any]] = None,
+    ):
+        self.source = source
+        self.user_id = user_id
+        self.session_id = session_id
+        self.device_info = device_info or {}
+        self.preferences = preferences or {}
+
+
+class StandardizedInput:
+    """标准化输入结构"""
+
+    def __init__(
+        self,
+        instruction: str,
+        context: InputContext,
+        metadata: Optional[Dict[str, Any]] = None,
+        attachments: Optional[Dict[str, Any]] = None,
+    ):
+        self.instruction = instruction
+        self.context = context
+        self.metadata = metadata or {}
+        self.attachments = attachments or {}
+
+
+class InputAdapter(ABC):
+    """输入适配器基类"""
+
+    @abstractmethod
+    def can_handle(self, raw_input: Any, source: InputSource) -> bool:
+        """检查是否能处理特定类型的输入"""
+        pass
+
+    @abstractmethod
+    def adapt(self, raw_input: Any, context: InputContext) -> StandardizedInput:
+        """将原始输入适配为标准化输入"""
+        pass
+
+    @abstractmethod
+    def validate(self, standardized_input: StandardizedInput) -> bool:
+        """验证标准化输入的有效性"""
+        pass

aiforge/adapters/input/input_adapter_manager.py

@@ -0,0 +1,101 @@
+from typing import List, Dict, Any, Optional
+from .input_adapter import InputAdapter, InputSource, InputContext, StandardizedInput
+from .cli_input_adapter import CLIInputAdapter
+from .gui_input_adapter import GUIInputAdapter
+from .web_input_adapter import WebInputAdapter
+from .mobile_input_adapter import MobileInputAdapter
+from .voice_input_adapter import VoiceInputAdapter
+
+
+class InputAdapterManager:
+    """输入适配管理器"""
+
+    def __init__(self):
+        self.adapters: List[InputAdapter] = [
+            CLIInputAdapter(),
+            GUIInputAdapter(),
+            WebInputAdapter(),
+            MobileInputAdapter(),
+            VoiceInputAdapter(),
+        ]
+
+        # 输入预处理器
+        self.preprocessors = []
+
+        # 输入后处理器
+        self.postprocessors = []
+
+    def register_adapter(self, adapter: InputAdapter):
+        """注册自定义适配器"""
+        self.adapters.append(adapter)
+
+    def adapt_input(
+        self, raw_input: Any, source: InputSource, context_data: Optional[Dict[str, Any]] = None
+    ) -> StandardizedInput:
+        """适配输入"""
+        # 创建输入上下文
+        context = self._create_context(source, context_data or {})
+
+        # 预处理
+        processed_input = self._preprocess(raw_input, context)
+
+        # 找到合适的适配器
+        adapter = self._find_adapter(processed_input, source)
+        if not adapter:
+            raise ValueError(f"No adapter found for source: {source}")
+
+        # 执行适配
+        standardized_input = adapter.adapt(processed_input, context)
+
+        # 验证
+        if not adapter.validate(standardized_input):
+            raise ValueError("Input validation failed")
+
+        # 后处理
+        final_input = self._postprocess(standardized_input)
+
+        return final_input
+
+    def _create_context(self, source: InputSource, context_data: Dict[str, Any]) -> InputContext:
+        """创建输入上下文"""
+        return InputContext(
+            source=source,
+            user_id=context_data.get("user_id"),
+            session_id=context_data.get("session_id"),
+            device_info=context_data.get("device_info", {}),
+            preferences=context_data.get("preferences", {}),
+        )
+
+    def _find_adapter(self, raw_input: Any, source: InputSource) -> Optional[InputAdapter]:
+        """找到合适的适配器"""
+        for adapter in self.adapters:
+            if adapter.can_handle(raw_input, source):
+                return adapter
+        return None
+
+    def _preprocess(self, raw_input: Any, context: InputContext) -> Any:
+        """预处理输入"""
+        processed = raw_input
+        for preprocessor in self.preprocessors:
+            processed = preprocessor.process(processed, context)
+        return processed
+
+    def _postprocess(self, standardized_input: StandardizedInput) -> StandardizedInput:
+        """后处理标准化输入"""
+        processed = standardized_input
+        for postprocessor in self.postprocessors:
+            processed = postprocessor.process(processed)
+        return processed
+
+    def get_supported_sources(self) -> List[InputSource]:
+        """获取支持的输入源"""
+        return list(InputSource)
+
+    def get_adapter_stats(self) -> Dict[str, Any]:
+        """获取适配器统计信息"""
+        return {
+            "total_adapters": len(self.adapters),
+            "supported_sources": [source.value for source in self.get_supported_sources()],
+            "preprocessors": len(self.preprocessors),
+            "postprocessors": len(self.postprocessors),
+        }

aiforge/adapters/input/input_processors.py

@@ -0,0 +1,48 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from .input_adapter import InputContext, StandardizedInput
+
+
+class InputPreprocessor(ABC):
+    """输入预处理器基类"""
+
+    @abstractmethod
+    def process(self, raw_input: Any, context: InputContext) -> Any:
+        pass
+
+
+class InputPostprocessor(ABC):
+    """输入后处理器基类"""
+
+    @abstractmethod
+    def process(self, standardized_input: StandardizedInput) -> StandardizedInput:
+        pass
+
+
+class TextCleanupPreprocessor(InputPreprocessor):
+    """文本清理预处理器"""
+
+    def process(self, raw_input: Any, context: InputContext) -> Any:
+        if isinstance(raw_input, str):
+            # 清理多余空白字符
+            return raw_input.strip()
+        elif isinstance(raw_input, dict) and "text" in raw_input:
+            raw_input["text"] = raw_input["text"].strip()
+        return raw_input
+
+
+class SecurityValidationPostprocessor(InputPostprocessor):
+    """安全验证后处理器"""
+
+    def process(self, standardized_input: StandardizedInput) -> StandardizedInput:
+        # 检查指令长度
+        if len(standardized_input.instruction) > 100000:
+            raise ValueError("Instruction too long")
+
+        # 检查恶意内容（简单示例）
+        dangerous_patterns = ["rm -rf", "del /", "format c:"]
+        for pattern in dangerous_patterns:
+            if pattern.lower() in standardized_input.instruction.lower():
+                raise ValueError(f"Potentially dangerous instruction detected: {pattern}")
+
+        return standardized_input

aiforge/adapters/input/mobile_input_adapter.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from .input_adapter import InputAdapter, InputSource, InputContext, StandardizedInput
+
+
+class MobileInputAdapter(InputAdapter):
+    """移动端输入适配器"""
+
+    def can_handle(self, raw_input: Any, source: InputSource) -> bool:
+        return source == InputSource.MOBILE and isinstance(raw_input, dict)
+
+    def adapt(self, raw_input: Any, context: InputContext) -> StandardizedInput:
+        """适配移动端输入"""
+        instruction = raw_input.get("text", "")
+
+        # 移动端特定的元数据
+        metadata = {
+            "input_type": "mobile_input",
+            "input_method": raw_input.get("input_method", "touch"),  # touch, voice, gesture
+            "orientation": context.device_info.get("orientation", "portrait"),
+            "device_type": context.device_info.get("device_type", "phone"),  # phone, tablet
+            "os": context.device_info.get("os", "unknown"),
+            "app_version": context.device_info.get("app_version", ""),
+            "network_type": context.device_info.get("network", "wifi"),
+            "battery_level": context.device_info.get("battery", 100),
+            "location": raw_input.get("location", {}) if raw_input.get("location_enabled") else {},
+        }
+
+        # 处理移动端特有的输入
+        attachments = {}
+        if "photos" in raw_input:
+            attachments["photos"] = raw_input["photos"]
+        if "voice_recording" in raw_input:
+            attachments["voice"] = raw_input["voice_recording"]
+        if "camera_capture" in raw_input:
+            attachments["camera"] = raw_input["camera_capture"]
+
+        return StandardizedInput(
+            instruction=instruction, context=context, metadata=metadata, attachments=attachments
+        )
+
+    def validate(self, standardized_input: StandardizedInput) -> bool:
+        """验证移动端输入"""
+        # 移动端输入可能更简短
+        return (
+            bool(standardized_input.instruction.strip())
+            and len(standardized_input.instruction) <= 5000
+        )

aiforge/adapters/input/voice_input_adapter.py

@@ -0,0 +1,44 @@
+from typing import Any
+
+from .input_adapter import InputAdapter, InputSource, InputContext, StandardizedInput
+
+
+class VoiceInputAdapter(InputAdapter):
+    """语音输入适配器"""
+
+    def can_handle(self, raw_input: Any, source: InputSource) -> bool:
+        return source == InputSource.VOICE and isinstance(raw_input, dict)
+
+    def adapt(self, raw_input: Any, context: InputContext) -> StandardizedInput:
+        """适配语音输入"""
+        # 语音转文字后的指令
+        instruction = raw_input.get("transcribed_text", "")
+
+        # 语音特定的元数据
+        metadata = {
+            "input_type": "voice_input",
+            "audio_format": raw_input.get("audio_format", "wav"),
+            "sample_rate": raw_input.get("sample_rate", 16000),
+            "duration": raw_input.get("duration", 0),
+            "confidence_score": raw_input.get("confidence", 0.0),
+            "language": raw_input.get("detected_language", "zh-CN"),
+            "speaker_id": raw_input.get("speaker_id"),
+            "noise_level": raw_input.get("noise_level", "low"),
+            "transcription_engine": raw_input.get("engine", "default"),
+        }
+
+        # 保存原始音频数据
+        attachments = {}
+        if "audio_data" in raw_input:
+            attachments["audio"] = raw_input["audio_data"]
+
+        return StandardizedInput(
+            instruction=instruction, context=context, metadata=metadata, attachments=attachments
+        )
+
+    def validate(self, standardized_input: StandardizedInput) -> bool:
+        """验证语音输入"""
+        confidence = standardized_input.metadata.get("confidence_score", 0.0)
+        return (
+            bool(standardized_input.instruction.strip()) and confidence >= 0.6  # 语音识别置信度阈值
+        )

aiforge/adapters/input/web_input_adapter.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from .input_adapter import InputAdapter, InputSource, InputContext, StandardizedInput
+
+
+class WebInputAdapter(InputAdapter):
+    """Web输入适配器"""
+
+    def can_handle(self, raw_input: Any, source: InputSource) -> bool:
+        return source == InputSource.WEB and isinstance(raw_input, dict)
+
+    def adapt(self, raw_input: Any, context: InputContext) -> StandardizedInput:
+        """适配Web输入"""
+        instruction = raw_input.get("instruction", "")
+
+        # Web特定的元数据
+        metadata = {
+            "input_type": "web_request",
+            "http_method": raw_input.get("method", "POST"),
+            "user_agent": raw_input.get("user_agent", ""),
+            "ip_address": raw_input.get("ip_address", ""),
+            "referrer": raw_input.get("referrer", ""),
+            "browser_info": context.device_info.get("browser", {}),
+            "viewport": context.device_info.get("viewport", {}),
+            "request_id": raw_input.get("request_id"),
+        }
+
+        # 处理Web特有的参数
+        if "form_data" in raw_input:
+            metadata["form_data"] = raw_input["form_data"]
+        if "query_params" in raw_input:
+            metadata["query_params"] = raw_input["query_params"]
+
+        # 处理文件上传
+        attachments = {}
+        if "uploaded_files" in raw_input:
+            attachments["files"] = raw_input["uploaded_files"]
+
+        return StandardizedInput(
+            instruction=instruction, context=context, metadata=metadata, attachments=attachments
+        )
+
+    def validate(self, standardized_input: StandardizedInput) -> bool:
+        """验证Web输入"""
+        return (
+            bool(standardized_input.instruction.strip())
+            and len(standardized_input.instruction) <= 50000  # Web输入可以更长
+        )

aiforge/adapters/output/__init__.py

@@ -0,0 +1,5 @@
+from .rule_based_adapter import RuleBasedAdapter
+from .ui_type_recommender import UITypeRecommender
+from .task_type_detector import TaskTypeDetector
+
+__all__ = ["RuleBasedAdapter", "UITypeRecommender", "TaskTypeDetector"]

aiforge/adapters/output/ai_ui_adapter.py

@@ -0,0 +1,120 @@
+import json
+import hashlib
+from typing import Dict, Any
+from ...llm.llm_client import AIForgeLLMClient
+
+
+class AIUIAdapter:
+    """AI驱动的UI适配器"""
+
+    def __init__(self, llm_client: AIForgeLLMClient):
+        self.llm_client = llm_client
+        self.cache = {}  # 简单的内存缓存
+
+    def adapt_for_display(self, data: Dict[str, Any], ui_context: str) -> Dict[str, Any]:
+        """根据UI上下文需求，让AI分析并转换数据格式"""
+        # 生成缓存键
+        cache_key = self._generate_cache_key(data, ui_context)
+
+        # 检查缓存
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+
+        # AI分析
+        prompt = self._build_adaptation_prompt(data, ui_context)
+
+        try:
+            response = self.llm_client.generate_code(prompt, "")
+            adapted_result = self._parse_adaptation_result(response)
+
+            # 缓存结果
+            self.cache[cache_key] = adapted_result
+
+            return adapted_result
+        except Exception:
+            # 失败时返回基础格式
+            return self._create_fallback_format(data, ui_context)
+
+    def _build_adaptation_prompt(self, data: Dict[str, Any], ui_context: str) -> str:
+        """构建适配提示词"""
+        return f"""
+# 任务：数据格式适配
+你需要将原始数据转换为适合特定界面展示的格式。
+
+## 原始数据
+{json.dumps(data, ensure_ascii=False, indent=2)}
+
+## 目标界面类型
+{ui_context}
+
+## 输出要求
+请返回以下JSON格式：
+{{
+    "display_items": [
+        {{
+            "type": "text|table|card|list|chart",
+            "title": "显示标题",
+            "content": "具体内容",
+            "priority": 1-10
+        }}
+    ],
+    "layout_hints": {{
+        "layout_type": "vertical|horizontal|grid",
+        "columns": 1-4,
+        "spacing": "compact|normal|loose"
+    }},
+    "actions": [
+        {{
+            "label": "操作名称",
+            "action": "refresh|export|detail",
+            "data": {{}}
+        }}
+    ],
+    "summary_text": "数据摘要文本"
+}}
+
+请严格按照JSON格式返回，不要包含其他解释文字。
+"""
+
+    def _parse_adaptation_result(self, response: str) -> Dict[str, Any]:
+        """解析AI适配结果"""
+        # 提取JSON内容
+        import re
+
+        json_match = re.search(r"\{.*\}", response, re.DOTALL)
+        if json_match:
+            try:
+                return json.loads(json_match.group(0))
+            except json.JSONDecodeError:
+                pass
+
+        # 解析失败时返回默认结构
+        return {
+            "display_items": [
+                {"type": "text", "title": "数据", "content": str(response)[:200], "priority": 5}
+            ],
+            "layout_hints": {"layout_type": "vertical", "columns": 1, "spacing": "normal"},
+            "actions": [],
+            "summary_text": "AI适配解析失败",
+        }
+
+    def _generate_cache_key(self, data: Dict[str, Any], ui_context: str) -> str:
+        """生成缓存键"""
+        content = f"{json.dumps(data, sort_keys=True)}_{ui_context}"
+        return hashlib.md5(content.encode()).hexdigest()[:16]
+
+    def _create_fallback_format(self, data: Dict[str, Any], ui_context: str) -> Dict[str, Any]:
+        """创建回退格式"""
+        return {
+            "display_items": [
+                {
+                    "type": "text",
+                    "title": "原始数据",
+                    "content": json.dumps(data, ensure_ascii=False, indent=2),
+                    "priority": 5,
+                }
+            ],
+            "layout_hints": {"layout_type": "vertical", "columns": 1, "spacing": "normal"},
+            "actions": [{"label": "刷新", "action": "refresh", "data": {}}],
+            "summary_text": f"显示原始数据 ({ui_context})",
+        }