stigmergy 1.0.68 → 1.0.70

package/src/collaboration/hooks.py

@@ -1,315 +0,0 @@
-"""
-AI CLI 协同钩子系统
-为每个CLI工具提供项目协同感知能力
-"""
-
-import os
-import json
-import logging
-from pathlib import Path
-from typing import Dict, List, Optional, Any
-from datetime import datetime, timezone
-from dataclasses import asdict
-import threading
-import time
-
-logger = logging.getLogger(__name__)
-
-class CollaborationHook:
-    """协同钩子基类"""
-
-    def __init__(self, cli_name: str, project_root: Optional[Path] = None):
-        self.cli_name = cli_name
-        self.project_root = project_root or Path.cwd()
-        self.constitution_file = self.project_root / "PROJECT_CONSTITUTION.json"
-        self.state_file = self.project_root / "PROJECT_STATE.json"
-        self.tasks_file = self.project_root / "TASKS.json"
-        self.collaboration_file = self.project_root / "COLLABORATION_LOG.json"
-
-        self.constitution_cache = {}
-        self.state_cache = {}
-        self.cache_timestamp = 0
-        self.cache_ttl = 30  # 缓存30秒
-
-        logger.info(f"协同钩子初始化: {cli_name} @ {self.project_root}")
-
-    def is_project_enabled(self) -> bool:
-        """检查项目是否启用协同功能"""
-        if not self.constitution_file.exists():
-            return False
-
-        try:
-            with open(self.constitution_file, 'r', encoding='utf-8') as f:
-                constitution = json.load(f)
-                return constitution.get("collaboration_config", {}).get("enabled", False)
-        except Exception:
-            return False
-
-    def _refresh_cache(self):
-        """刷新缓存"""
-        current_time = time.time()
-        if current_time - self.cache_timestamp > self.cache_ttl:
-            self.cache_timestamp = current_time
-
-            # 重新加载项目宪法
-            if self.constitution_file.exists():
-                try:
-                    with open(self.constitution_file, 'r', encoding='utf-8') as f:
-                        self.constitution_cache = json.load(f)
-                except Exception as e:
-                    logger.warning(f"加载项目宪法失败: {e}")
-
-            # 重新加载项目状态
-            if self.state_file.exists():
-                try:
-                    with open(self.state_file, 'r', encoding='utf-8') as f:
-                        self.state_cache = json.load(f)
-                except Exception as e:
-                    logger.warning(f"加载项目状态失败: {e}")
-
-    def get_project_constitution(self) -> Dict:
-        """获取项目宪法"""
-        self._refresh_cache()
-        return self.constitution_cache
-
-    def get_project_state(self) -> Dict:
-        """获取项目状态"""
-        self._refresh_cache()
-        return self.state_cache
-
-    def detect_collaboration_intent(self, user_input: str) -> Dict:
-        """检测协作意图"""
-        if not self.is_project_enabled():
-            return {"intent": False}
-
-        constitution = self.get_project_constitution()
-        collaboration_keywords = constitution.get("cli_preferences", {}).get("collaboration_keywords", [])
-
-        # 检测协作关键词
-        user_input_lower = user_input.lower()
-        for keyword in collaboration_keywords:
-            if keyword in user_input_lower:
-                return {
-                    "intent": True,
-                    "keyword": keyword,
-                    "detected_at": datetime.now(timezone.utc).isoformat()
-                }
-
-        return {"intent": False}
-
-    def get_next_task(self) -> Optional[Dict]:
-        """获取下一个任务"""
-        if not self.is_project_enabled():
-            return None
-
-        # 这里应该调用任务管理器获取任务
-        # 为了简化，直接检查任务文件
-        if not self.tasks_file.exists():
-            return None
-
-        try:
-            with open(self.tasks_file, 'r', encoding='utf-8') as f:
-                tasks_data = json.load(f)
-
-            # 获取CLI优先级
-            constitution = self.get_project_constitution()
-            cli_preferences = constitution.get("cli_preferences", {})
-            task_priorities = cli_preferences.get("task_priorities", {}).get(self.cli_name, [])
-
-            # 查找待处理任务
-            pending_tasks = [task for task in tasks_data.get("tasks", [])
-                            if task.get("status") == "pending"]
-
-            if not pending_tasks:
-                return None
-
-            # 简单优先级排序
-            priority_scores = {"critical": 4, "high": 3, "normal": 2, "low": 1}
-
-            def task_score(task):
-                score = priority_scores.get(task.get("priority", "normal"), 2)
-
-                # CLI偏好加分
-                if task.get("tags"):
-                    for tag in task.get("tags", []):
-                        if tag in task_priorities:
-                            score += 2
-
-                return score
-
-            pending_tasks.sort(key=task_score, reverse=True)
-            return pending_tasks[0]
-
-        except Exception as e:
-            logger.error(f"获取下一个任务失败: {e}")
-            return None
-
-    def create_task(self, title: str, description: str, **kwargs) -> bool:
-        """创建新任务"""
-        if not self.is_project_enabled():
-            logger.warning("项目未启用协同功能")
-            return False
-
-        try:
-            # 这里应该调用任务管理器创建任务
-            # 为了简化，直接修改任务文件
-            tasks_data = {"tasks": [], "next_id": 1}
-
-            if self.tasks_file.exists():
-                with open(self.tasks_file, 'r', encoding='utf-8') as f:
-                    tasks_data = json.load(f)
-
-            # 创建新任务
-            task_id = f"task_{tasks_data['next_id']:04d}"
-            task = {
-                "id": task_id,
-                "title": title,
-                "description": description,
-                "status": "pending",
-                "priority": "normal",
-                "assigned_to": self.cli_name,
-                "created_by": self.cli_name,
-                "created_at": datetime.now(timezone.utc).isoformat(),
-                "updated_at": datetime.now(timezone.utc).isoformat(),
-                "tags": [],
-                "metadata": kwargs
-            }
-
-            tasks_data["tasks"].append(task)
-            tasks_data["next_id"] += 1
-
-            with open(self.tasks_file, 'w', encoding='utf-8') as f:
-                json.dump(tasks_data, f, indent=2, ensure_ascii=False)
-
-            # 记录协作日志
-            self._log_activity("task_created", {
-                "task_id": task_id,
-                "title": title,
-                "assigned_to": self.cli_name
-            })
-
-            logger.info(f"✅ 任务创建成功: {task_id}")
-            return True
-
-        except Exception as e:
-            logger.error(f"创建任务失败: {e}")
-            return False
-
-    def update_task_status(self, task_id: str, status: str, **kwargs) -> bool:
-        """更新任务状态"""
-        if not self.is_project_enabled():
-            return False
-
-        try:
-            if not self.tasks_file.exists():
-                return False
-
-            with open(self.tasks_file, 'r', encoding='utf-8') as f:
-                tasks_data = json.load(f)
-
-            # 查找并更新任务
-            for task in tasks_data.get("tasks", []):
-                if task.get("id") == task_id:
-                    task["status"] = status
-                    task["updated_at"] = datetime.now(timezone.utc).isoformat()
-                    task.update(kwargs)
-
-                    # 如果任务完成，记录完成时间
-                    if status == "completed":
-                        task["completed_at"] = datetime.now(timezone.utc).isoformat()
-
-                        # 记录协作日志
-                        self._log_activity("task_completed", {
-                            "task_id": task_id,
-                            "title": task.get("title", ""),
-                            "assigned_to": task.get("assigned_to", "")
-                        })
-                    else:
-                        # 记录协作日志
-                        self._log_activity("task_status_updated", {
-                            "task_id": task_id,
-                            "old_status": task.get("status"),
-                            "new_status": status,
-                            "assigned_to": task.get("assigned_to", "")
-                        })
-
-                    break
-
-            with open(self.tasks_file, 'w', encoding='utf-8') as f:
-                json.dump(tasks_data, f, indent=2, ensure_ascii=False)
-
-            logger.info(f"✅ 任务状态更新: {task_id} -> {status}")
-            return True
-
-        except Exception as e:
-            logger.error(f"更新任务状态失败: {e}")
-            return False
-
-    def _log_activity(self, action: str, details: Dict):
-        """记录协作活动"""
-        try:
-            log_entry = {
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-                "cli": self.cli_name,
-                "action": action,
-                "details": details
-            }
-
-            logs = []
-            if self.collaboration_file.exists():
-                with open(self.collaboration_file, 'r', encoding='utf-8') as f:
-                    logs = json.load(f)
-
-            logs.append(log_entry)
-
-            # 限制日志大小
-            if len(logs) > 1000:
-                logs = logs[-1000:]
-
-            with open(self.collaboration_file, 'w', encoding='utf-8') as f:
-                json.dump(logs, f, indent=2, ensure_ascii=False)
-
-        except Exception as e:
-            logger.error(f"记录协作日志失败: {e}")
-
-class CLICollaborationHooks:
-    """CLI协作钩子集合"""
-
-    _hooks = {}
-    _lock = threading.Lock()
-
-    @classmethod
-    def register_hook(cls, cli_name: str, hook: CollaborationHook):
-        """注册协作钩子"""
-        with cls._lock:
-            cls._hooks[cli_name] = hook
-            logger.info(f"注册协作钩子: {cli_name}")
-
-    @classmethod
-    def get_hook(cls, cli_name: str) -> Optional[CollaborationHook]:
-        """获取协作钩子"""
-        with cls._lock:
-            return cls._hooks.get(cli_name)
-
-    @classmethod
-    def initialize_hook(cls, cli_name: str, project_root: Optional[Path] = None):
-        """初始化协作钩子"""
-        if cls.get_hook(cli_name) is None:
-            hook = CollaborationHook(cli_name, project_root)
-            cls.register_hook(cli_name, hook)
-            logger.info(f"初始化协作钩子: {cli_name}")
-            return hook
-
-        return cls.get_hook(cli_name)
-
-# 预定义的CLI工具钩子
-def initialize_standard_hooks():
-    """初始化标准CLI工具的协作钩子"""
-
-    standard_clis = ["claude", "gemini", "codex", "qwencode", "codebuddy", "iflow", "qoder", "copilot"]
-
-    for cli_name in standard_clis:
-        CLICollaborationHooks.initialize_hook(cli_name)
-
-# 全局初始化
-initialize_standard_hooks()

package/src/core/__init__.py

@@ -1,21 +0,0 @@
-
-"""
-AI CLI Router - 核心模块
-AI CLI协作系统的核心组件
-"""
-
-# 导入核心类和函数
-from .models import *
-from .ai_environment_scanner import AIEnvironmentScanner
-from .enhanced_init_processor import EnhancedInitProcessor
-from .md_enhancer import MDDocumentEnhancer
-from .md_generator import MDDocumentGenerator
-
-# 版本信息
-__version__ = '1.0.0'
-__all__ = [
-    'AIEnvironmentScanner',
-    'EnhancedInitProcessor', 
-    'MDDocumentEnhancer',
-    'MDDocumentGenerator'
-]

package/src/core/ai_environment_scanner.py

@@ -1,331 +0,0 @@
-"""
-AI Environment Scanner - AI环境扫描器
-检测项目可用的AI CLI工具和协作环境
-"""
-import os
-import asyncio
-import json
-import yaml
-import subprocess
-import logging
-from pathlib import Path
-from typing import Dict, List, Optional, Any
-from datetime import datetime
-
-from .models import (
-    CLIInfo, ProjectCLIInfo, AIEnvironmentInfo, CollaborationGuide,
-    CLIStatus, IntegrationType, CLI_CONFIG_MAPPING, COLLABORATION_PROTOCOLS
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AIEnvironmentScanner:
-    """AI环境扫描器 - 检测项目可用的AI协作工具"""
-
-    def __init__(self, current_cli: str = None):
-        self.current_cli = current_cli
-        self.scan_start_time = None
-
-    async def scan_ai_environment(self, project_path: str) -> AIEnvironmentInfo:
-        """扫描当前项目的AI环境"""
-        self.scan_start_time = datetime.now()
-
-        try:
-            # 1. 检测全局已安装的CLI工具
-            logger.info("开始扫描全局CLI工具...")
-            global_clis = await self._scan_global_clis()
-
-            # 2. 检测项目特定的AI配置
-            logger.info("开始扫描项目特定配置...")
-            project_clis = await self._scan_project_clis(project_path)
-
-            # 3. 生成协作指南
-            logger.info("生成协作指南...")
-            collaboration_guide = await self._generate_collaboration_guide(global_clis, project_clis)
-
-            scan_duration = (datetime.now() - self.scan_start_time).total_seconds()
-
-            ai_environment = AIEnvironmentInfo(
-                available_clis=global_clis,
-                project_specific_clis=project_clis,
-                collaboration_guide=collaboration_guide,
-                generated_at=self.scan_start_time,
-                scan_duration=scan_duration
-            )
-
-            logger.info(f"AI环境扫描完成，耗时: {scan_duration:.2f}秒")
-            return ai_environment
-
-        except Exception as e:
-            logger.error(f"AI环境扫描失败: {e}")
-            raise
-
-    async def _scan_global_clis(self) -> Dict[str, CLIInfo]:
-        """扫描全局已安装的AI CLI工具"""
-        available_clis = {}
-
-        scan_tasks = []
-        for cli_name, config_mapping in CLI_CONFIG_MAPPING.items():
-            task = self._scan_single_cli(cli_name, config_mapping)
-            scan_tasks.append(task)
-
-        # 并行扫描所有CLI工具
-        results = await asyncio.gather(*scan_tasks, return_exceptions=True)
-
-        for i, (cli_name, config_mapping) in enumerate(CLI_CONFIG_MAPPING.items()):
-            result = results[i]
-            if isinstance(result, Exception):
-                logger.warning(f"扫描 {cli_name} 时出错: {result}")
-                continue
-
-            if result:
-                available_clis[cli_name] = result
-
-        logger.info(f"发现 {len(available_clis)} 个可用的CLI工具: {list(available_clis.keys())}")
-        return available_clis
-
-    async def _scan_single_cli(self, cli_name: str, config_mapping) -> Optional[CLIInfo]:
-        """扫描单个CLI工具"""
-        try:
-            # 1. 检查CLI工具是否可用
-            is_available = await self._is_cli_available(cli_name, config_mapping)
-            if not is_available:
-                return None
-
-            # 2. 获取版本信息
-            version = await self._get_cli_version(cli_name, config_mapping)
-
-            # 3. 获取能力信息
-            capabilities = await self._get_cli_capabilities(cli_name, config_mapping)
-
-            # 4. 检查配置文件
-            config_file_exists = await self._check_config_file(config_mapping.config_file)
-
-            status = CLIStatus.AVAILABLE if config_file_exists else CLIStatus.CONFIG_MISSING
-
-            return CLIInfo(
-                name=cli_name,
-                display_name=self._get_display_name(cli_name),
-                version=version,
-                integration_type=config_mapping.integration_type,
-                status=status,
-                capabilities=capabilities,
-                config_file=config_mapping.config_file,
-                global_doc=config_mapping.global_doc,
-                protocols=COLLABORATION_PROTOCOLS["chinese"] + COLLABORATION_PROTOCOLS["english"]
-            )
-
-        except Exception as e:
-            logger.warning(f"扫描CLI工具 {cli_name} 失败: {e}")
-            return None
-
-    async def _is_cli_available(self, cli_name: str, config_mapping) -> bool:
-        """检查CLI工具是否可用"""
-        try:
-            # 检查命令是否存在
-            command = config_mapping.version_check_command
-            if not command:
-                # 如果没有版本检查命令，尝试通用命令
-                command = f"{cli_name}-cli --version"
-
-            result = await asyncio.create_subprocess_shell(
-                command,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            stdout, stderr = await result.communicate()
-
-            return result.returncode == 0
-
-        except Exception:
-            return False
-
-    async def _get_cli_version(self, cli_name: str, config_mapping) -> str:
-        """获取CLI工具版本"""
-        try:
-            command = config_mapping.version_check_command
-            if not command:
-                command = f"{cli_name}-cli --version"
-
-            result = await asyncio.create_subprocess_shell(
-                command,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            stdout, stderr = await result.communicate()
-
-            if result.returncode == 0:
-                version_output = stdout.decode().strip() or stderr.decode().strip()
-                # 提取版本号
-                for line in version_output.split('\n'):
-                    if any(keyword in line.lower() for keyword in ['version', 'v']):
-                        return line.strip()
-                return version_output
-            else:
-                return "Unknown"
-
-        except Exception:
-            return "Unknown"
-
-    async def _get_cli_capabilities(self, cli_name: str, config_mapping) -> List[str]:
-        """获取CLI工具能力"""
-        # 基于集成类型返回默认能力
-        capability_map = {
-            IntegrationType.HOOK_SYSTEM: ["钩子系统", "事件处理", "跨工具协调"],
-            IntegrationType.EXTENSION_SYSTEM: ["扩展系统", "智能匹配", "多处理器"],
-            IntegrationType.CLASS_INHERITANCE: ["插件继承", "代码生成", "方法重写"],
-            IntegrationType.WORKFLOW_PIPELINE: ["工作流", "流水线处理", "任务队列"],
-            IntegrationType.NOTIFICATION_HOOK: ["通知系统", "实时监控", "事件通知"],
-            IntegrationType.MCP_SERVER: ["MCP协议", "服务器集成", "自定义代理"],
-            IntegrationType.SLASH_COMMAND: ["斜杠命令", "快速执行", "参数化命令"]
-        }
-
-        return capability_map.get(config_mapping.integration_type, ["通用AI助手"])
-
-    async def _check_config_file(self, config_file_path: str) -> bool:
-        """检查配置文件是否存在"""
-        try:
-            expanded_path = Path(config_file_path.expanduser())
-            return expanded_path.exists() and expanded_path.is_file()
-        except Exception:
-            return False
-
-    def _get_display_name(self, cli_name: str) -> str:
-        """获取CLI工具显示名称"""
-        display_names = {
-            "claude": "Claude CLI",
-            "gemini": "Gemini CLI",
-            "qwen": "QwenCode CLI",
-            "iflow": "iFlow CLI",
-            "qoder": "Qoder CLI",
-            "codebuddy": "CodeBuddy CLI",
-            "copilot": "Copilot CLI",
-            "codex": "Codex CLI"
-        }
-        return display_names.get(cli_name, cli_name.upper())
-
-    async def _scan_project_clis(self, project_path: str) -> Dict[str, ProjectCLIInfo]:
-        """扫描项目特定的AI配置"""
-        project_clis = {}
-
-        # 检查项目目录下的AI配置文件
-        ai_config_files = [
-            ".ai-config.json",
-            ".claude-project.json",
-            ".gemini-project.json",
-            ".qwen-project.json",
-            ".iflow-project.json",
-            "ai-workflow.yml",
-            ".ai-cli-unified.json"
-        ]
-
-        for config_file in ai_config_files:
-            config_path = Path(project_path) / config_file
-            if config_path.exists():
-                try:
-                    cli_configs = await self._parse_project_config(config_path)
-                    project_clis.update(cli_configs)
-                    logger.info(f"发现项目配置文件: {config_file}")
-                except Exception as e:
-                    logger.warning(f"解析项目配置文件 {config_file} 失败: {e}")
-
-        logger.info(f"发现 {len(project_clis)} 个项目特定CLI配置")
-        return project_clis
-
-    async def _parse_project_config(self, config_path: Path) -> Dict[str, ProjectCLIInfo]:
-        """解析项目配置文件"""
-        project_clis = {}
-
-        try:
-            with open(config_path, 'r', encoding='utf-8') as f:
-                if config_path.suffix.lower() in ['.yml', '.yaml']:
-                    config_data = yaml.safe_load(f)
-                else:
-                    config_data = json.load(f)
-
-            # 根据配置文件格式解析CLI配置
-            if 'ai_tools' in config_data:
-                for cli_name, cli_config in config_data['ai_tools'].items():
-                    project_clis[cli_name] = ProjectCLIInfo(
-                        cli_name=cli_name,
-                        project_config=cli_config,
-                        custom_settings=cli_config.get('custom_settings', {}),
-                        enabled_features=cli_config.get('enabled_features', [])
-                    )
-            elif 'tools' in config_data:
-                # 简化格式
-                for cli_config in config_data['tools']:
-                    cli_name = cli_config.get('name')
-                    if cli_name:
-                        project_clis[cli_name] = ProjectCLIInfo(
-                            cli_name=cli_name,
-                            project_config=cli_config,
-                            custom_settings=cli_config.get('custom_settings', {}),
-                            enabled_features=cli_config.get('enabled_features', [])
-                        )
-
-        except Exception as e:
-            logger.error(f"解析配置文件失败 {config_path}: {e}")
-            raise
-
-        return project_clis
-
-    async def _generate_collaboration_guide(self,
-                                           global_clis: Dict[str, CLIInfo],
-                                           project_clis: Dict[str, ProjectCLIInfo]) -> CollaborationGuide:
-        """生成协作指南"""
-
-        # 合并全局和项目特定的CLI信息
-        all_clis = {**global_clis}
-        for cli_name, project_cli in project_clis.items():
-            if cli_name in all_clis:
-                # 增强现有CLI信息
-                existing_cli = all_clis[cli_name]
-                # 可以在这里添加项目特定的增强信息
-            else:
-                # 项目特定的CLI可能不在全局列表中
-                logger.info(f"项目特定CLI {cli_name} 不在全局列表中")
-
-        # 确定当前CLI工具
-        current_cli = self.current_cli or "claude"  # 默认值
-
-        # 生成可协作的伙伴列表（排除当前CLI）
-        peer_clis = {k: v for k, v in all_clis.items() if k != current_cli}
-
-        # 生成协作示例
-        examples = self._generate_collaboration_examples(current_cli, peer_clis)
-
-        return CollaborationGuide(
-            current_cli=current_cli,
-            available_peers=peer_clis,
-            protocols=COLLABORATION_PROTOCOLS,
-            examples=examples
-        )
-
-    def _generate_collaboration_examples(self, current_cli: str, peer_clis: Dict[str, CLIInfo]) -> List[str]:
-        """生成协作示例"""
-        examples = []
-
-        # 基于可用CLI工具生成示例
-        if "qwen" in peer_clis:
-            examples.append("请用qwen帮我生成单元测试")
-            examples.append("调用qwen来重构这个函数")
-
-        if "gemini" in peer_clis:
-            examples.append("用gemini分析代码性能")
-            examples.append("让gemini优化这个查询")
-
-        if "iflow" in peer_clis:
-            examples.append("用iflow创建CI/CD工作流")
-            examples.append("启动iflow部署流程")
-
-        if "claude" in peer_clis:
-            examples.append("请用claude审查这段代码")
-            examples.append("调用claude进行架构分析")
-
-        # 添加通用示例
-        examples.append("请用{tool}帮我{task}")
-        examples.append("call {tool} to {task}")
-
-        return examples