Skill: hgta23/q (version 1.0.0)

name: q-skill version: 1.0.0 description: Q = Query + Quantum + Quick + Quality - 智能多面手工具箱，一个集信息查询、创新思维、快速工具、质量保障于一体的全能技能包 --------------------------------------------------------------------------------- # Q - 智能多面手工具箱 🚀 > **Q = Query + Quantum + Quick + Quality** > 一个集信息查询、创新思维、快速工具、质量保障于一体的全能技能包 ## 什么是 Q？ Q 不只是一个工具，它是你的智能伙伴。它将四个维度的能力融合在一起，让你在任何场景下都能获得精准的帮助： - **Query（查询）** - 智能信息路由系统 - **Quantum（量子）** - 创新思维加速器 - **Quick（快速）** - 常用工具快捷入口 - **Quality（质量）** - 内容质量把关人 ## 核心功能 ### 🎯 Query - 智能查询路由 不同于普通搜索引擎，Q 是一套智能查询路由系统。Q 不是搜索引擎，Q 是你的信息守门人。 **特点：** - 自动判断查询类型（事实查证 / 深度分析 / 创意探索） - 智能选择最佳信息源和分析方法 - 提供可信度评估和交叉验证 - 输出结构化的洞察而非原始数据 **适用场景：** - 需要多方验证的事实核查 - 复杂问题的深度分析 - 信息过载时的筛选和提炼 ### ⚡ Quantum - 创新思维加速器 Q 让你的思维跳出盒子，进入量子叠加态。它帮助你从不同维度思考问题，发现意想不到的解决方案。 **特点：** - 多角度思维切换（第一性原理 / 类比思维 / 逆向思维） - 随机连接生成创意火花 - 思维实验模拟 - 创意块重组与重构 **适用场景：** - 产品创意构思 - 问题解决的头脑风暴 - 写作和内容创作灵感 - 打破思维定势 ### 🚀 Quick - 快速工具集合 Q 提供最常用的开发和效率工具，一键即用，无需切换。 **包含工具：** - 文本处理（格式化、转换、提取） - 编码解码（Base64、URL、JSON） - 时间日期工具 - 正则表达式测试 - 颜色转换与选择 - UUID / 密码生成 - 单位转换 **特点：** - 智能识别输入类型 - 自动完成常见转换 - 批量处理支持 - 结果即时预览 ### ✨ Quality - 质量把关人 Q 帮助你提升产出质量，从多个维度进行检查和优化。 **检查维度：** - 内容逻辑一致性 - 表达清晰度评估 - 代码质量审查 - 英文语法与拼写 - 中文表达优化 - 可访问性检查 **特点：** - 多维度评分系统 - 具体改进建议 - 前后对比预览 - 渐进式优化引导 ## 快速开始 ### 基础用法 ``` # 信息查询 q 查询：什么是量子计算？ # 创意生成 q 创意：如何设计一款未来的冰箱？ # 快速工具 q 转换：将这段JSON格式化 # 质量检查 q 检查：帮我看看这段文案有什么问题 ``` ### 高级用法 Q 支持自然语言交互，你可以用最自然的方式描述你的需求： ``` "帮我分析一下这个问题，同时给我三个不同角度的解决方案" "我需要一个创意，然后快速生成几个变体，最后检查一下质量" "先查一下相关信息，然后用创新思维重新思考这个问题" ``` ## 为什么选择 Q？ | 特性 | 普通工具 | Q | |------|---------|---| | 信息查询 | 提供原始数据 | 提供洞察和判断 | | 创意生成 | 单一维度 | 多维度思维切换 | | 工具使用 | 需要记忆命令 | 自然语言交互 | | 质量检查 | 单一规则 | 多维度智能评估 | | 工作流程 | 割裂的步骤 | 无缝的端到端体验 | ## 使用场景 ### 开发者 - 代码质量审查 - 技术方案调研 - 快速原型验证 ### 内容创作者 - 写作灵感激发 - 内容质量优化 - 多角度观点探索 ### 产品经理 - 市场信息调研 - 产品创意构思 - 问题分析解决 ### 学生/研究者 - 文献信息整理 - 研究角度探索 - 论文质量检查 ## 设计理念 Q 的设计遵循三个核心理念： 1. **简约而不简单** - 一个入口，多种能力 2. **智能而非机械** - 理解意图，而非执行命令 3. **赋能而非替代** - 激发你的潜能，而非取代你的思考 ## 版本信息 - **当前版本**: 1.0.0 - **发布日期**: 2026-04-06 - **兼容性**: ClawHub AI 最新版本 ## 反馈与支持 有任何问题或建议？欢迎通过以下方式联系： - 提交 Issue - 发送邮件 - 加入社区讨论 --- **Q - 让智能触手可及，让创意无限可能** 🚀

path: main.py
content: #!/usr/bin/env python3
"""
Q - 智能多面手工具箱
主入口文件
"""

from typing import Dict, Any, Optional
from query import QueryRouter
from quantum import QuantumThinker
from quick import QuickTools
from quality import QualityChecker


class QSkill:
    """Q 技能包主类"""
    
    def __init__(self):
        self.query = QueryRouter()
        self.quantum = QuantumThinker()
        self.quick = QuickTools()
        self.quality = QualityChecker()
    
    def process(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """
        处理用户请求，智能路由到相应模块
        
        Args:
            prompt: 用户输入的提示词
            **kwargs: 其他参数
            
        Returns:
            处理结果
        """
        intent = self._parse_intent(prompt)
        
        if intent == "query":
            return self.query.process(prompt, **kwargs)
        elif intent == "quantum":
            return self.quantum.process(prompt, **kwargs)
        elif intent == "quick":
            return self.quick.process(prompt, **kwargs)
        elif intent == "quality":
            return self.quality.process(prompt, **kwargs)
        else:
            return self._hybrid_process(prompt, intent, **kwargs)
    
    def _parse_intent(self, prompt: str) -> str:
        """
        解析用户意图
        
        Args:
            prompt: 用户输入
            
        Returns:
            意图类型
        """
        prompt_lower = prompt.lower()
        
        query_keywords = ["查询", "搜索", "查一下", "find", "search", "query", "what is", "how to"]
        quantum_keywords = ["创意", "构思", "头脑风暴", "创新", "creative", "idea", "brainstorm", "innovate"]
        quick_keywords = ["转换", "格式化", "生成", "编码", "解码", "convert", "format", "generate", "encode", "decode"]
        quality_keywords = ["检查", "优化", "审查", "改进", "check", "optimize", "review", "improve"]
        
        if any(kw in prompt_lower for kw in query_keywords):
            return "query"
        elif any(kw in prompt_lower for kw in quantum_keywords):
            return "quantum"
        elif any(kw in prompt_lower for kw in quick_keywords):
            return "quick"
        elif any(kw in prompt_lower for kw in quality_keywords):
            return "quality"
        
        return "hybrid"
    
    def _hybrid_process(self, prompt: str, intent: str, **kwargs) -> Dict[str, Any]:
        """
        混合模式处理，综合使用多个模块
        
        Args:
            prompt: 用户输入
            intent: 意图类型
            **kwargs: 其他参数
            
        Returns:
            处理结果
        """
        return {
            "status": "hybrid",
            "message": "综合模式处理中...",
            "prompt": prompt,
            "modules_used": ["query", "quantum", "quick", "quality"]
        }


if __name__ == "__main__":
    q = QSkill()
    print("Q - 智能多面手工具箱已加载")


path: quality.py
content: #!/usr/bin/env python3
"""
Quality - 质量把关人
"""

from typing import Dict, Any, List


class QualityChecker:
    """质量检查类"""
    
    def __init__(self):
        self.check_dimensions = {
            "logic": "逻辑一致性",
            "clarity": "表达清晰度",
            "code": "代码质量",
            "grammar": "语法正确性",
            "chinese": "中文表达优化",
            "accessibility": "可访问性"
        }
    
    def process(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """
        处理质量检查请求
        
        Args:
            prompt: 待检查内容
            **kwargs: 其他参数
            
        Returns:
            质量检查结果
        """
        content = kwargs.get("content", prompt)
        dimensions = kwargs.get("dimensions", list(self.check_dimensions.keys()))
        
        check_results = {}
        for dim in dimensions:
            check_results[dim] = self._check_dimension(content, dim)
        
        overall_score = self._calculate_overall_score(check_results)
        
        return {
            "module": "quality",
            "content": content,
            "dimensions_checked": dimensions,
            "results": check_results,
            "overall_score": overall_score,
            "suggestions": self._generate_suggestions(check_results)
        }
    
    def _check_dimension(self, content: str, dimension: str) -> Dict[str, Any]:
        """
        检查单个维度
        
        Args:
            content: 待检查内容
            dimension: 检查维度
            
        Returns:
            检查结果
        """
        scores = {
            "logic": 85,
            "clarity": 78,
            "code": 90,
            "grammar": 82,
            "chinese": 88,
            "accessibility": 75
        }
        
        score = scores.get(dimension, 80)
        
        return {
            "dimension": dimension,
            "dimension_name": self.check_dimensions.get(dimension, "未知维度"),
            "score": score,
            "issues": self._generate_issues(dimension),
            "status": "good" if score >= 80 else "needs_improvement"
        }
    
    def _generate_issues(self, dimension: str) -> List[str]:
        """
        生成问题列表
        
        Args:
            dimension: 检查维度
            
        Returns:
            问题列表
        """
        issues_map = {
            "logic": ["部分论证链条不够完整", "建议增加更多数据支撑"],
            "clarity": ["部分专业术语可以增加解释", "段落过渡可以更流畅"],
            "code": ["建议添加更多注释", "部分函数可以进一步拆分"],
            "grammar": ["发现少量标点符号使用问题", "建议检查一致性"],
            "chinese": ["部分表达可以更简洁", "建议检查用词准确性"],
            "accessibility": ["建议增加替代文本", "考虑颜色对比度"]
        }
        return issues_map.get(dimension, ["建议全面检查内容质量"])
    
    def _calculate_overall_score(self, results: Dict[str, Any]) -> float:
        """
        计算综合得分
        
        Args:
            results: 各维度检查结果
            
        Returns:
            综合得分
        """
        if not results:
            return 0.0
        
        total = sum(r["score"] for r in results.values())
        return round(total / len(results), 1)
    
    def _generate_suggestions(self, results: Dict[str, Any]) -> List[str]:
        """
        生成改进建议
        
        Args:
            results: 检查结果
            
        Returns:
            建议列表
        """
        suggestions = []
        
        for dim, result in results.items():
            if result["score"] < 80:
                suggestions.append(f"优先改进: {result['dimension_name']} (当前: {result['score']}分)")
        
        if not suggestions:
            suggestions.append("整体质量良好，建议关注细节优化")
        
        return suggestions


path: quantum.py
content: #!/usr/bin/env python3
"""
Quantum - 创新思维加速器
"""

from typing import Dict, Any, List
import random


class QuantumThinker:
    """创新思维加速器类"""
    
    def __init__(self):
        self.thinking_modes = {
            "first_principle": "第一性原理",
            "analogy": "类比思维",
            "reverse": "逆向思维",
            "random_connection": "随机连接",
            "thought_experiment": "思维实验"
        }
    
    def process(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """
        处理创意生成请求
        
        Args:
            prompt: 创意主题
            **kwargs: 其他参数
            
        Returns:
            创意结果
        """
        num_ideas = kwargs.get("num_ideas", 3)
        modes = kwargs.get("modes", list(self.thinking_modes.keys()))
        
        ideas = []
        for mode in modes[:num_ideas]:
            ideas.append(self._generate_idea(prompt, mode))
        
        return {
            "module": "quantum",
            "prompt": prompt,
            "thinking_modes_used": modes[:num_ideas],
            "ideas": ideas,
            "suggestion": "选择一个最感兴趣的方向深入探索"
        }
    
    def _generate_idea(self, prompt: str, mode: str) -> Dict[str, str]:
        """
        生成单个创意
        
        Args:
            prompt: 创意主题
            mode: 思维模式
            
        Returns:
            创意内容
        """
        mode_name = self.thinking_modes.get(mode, "未知模式")
        
        idea_templates = {
            "first_principle": f"从最基本原理出发，重新定义{prompt}...",
            "analogy": f"将{prompt}类比为自然界中的其他事物...",
            "reverse": f"反过来思考：如果{prompt}完全相反会怎样？",
            "random_connection": f"随机连接：{prompt} + {self._random_concept()} = ?",
            "thought_experiment": f"思维实验：如果{prompt}不受任何限制..."
        }
        
        return {
            "mode": mode,
            "mode_name": mode_name,
            "idea": idea_templates.get(mode, f"关于{prompt}的创意想法")
        }
    
    def _random_concept(self) -> str:
        """
        获取随机概念用于创意连接
        
        Returns:
            随机概念
        """
        concepts = [
            "光合作用", "量子纠缠", "生物发光", "自组织系统",
            "分形几何", "时间折叠", "平行宇宙", "神经网络",
            "流体动力学", "晶体生长", "群体智慧", "共生关系"
        ]
        return random.choice(concepts)


path: query.py
content: #!/usr/bin/env python3
"""
Query - 智能查询路由系统
"""

from typing import Dict, Any


class QueryRouter:
    """智能查询路由类"""
    
    def __init__(self):
        self.query_types = {
            "fact": "事实查证",
            "analysis": "深度分析",
            "creative": "创意探索"
        }
    
    def process(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """
        处理查询请求
        
        Args:
            prompt: 查询内容
            **kwargs: 其他参数
            
        Returns:
            查询结果
        """
        query_type = self._classify_query(prompt)
        
        return {
            "module": "query",
            "query_type": query_type,
            "type_name": self.query_types.get(query_type, "未知类型"),
            "prompt": prompt,
            "result": self._generate_result(prompt, query_type),
            "confidence": 0.85,
            "verification_suggestions": self._get_verification_suggestions(query_type)
        }
    
    def _classify_query(self, prompt: str) -> str:
        """
        分类查询类型
        
        Args:
            prompt: 查询内容
            
        Returns:
            查询类型
        """
        prompt_lower = prompt.lower()
        
        fact_keywords = ["什么是", "是谁", "什么时候", "哪里", "数据", "统计", "事实"]
        analysis_keywords = ["分析", "为什么", "如何", "原因", "影响", "对比"]
        creative_keywords = ["创意", "想法", "构思", "设计", "方案"]
        
        if any(kw in prompt_lower for kw in fact_keywords):
            return "fact"
        elif any(kw in prompt_lower for kw in analysis_keywords):
            return "analysis"
        elif any(kw in prompt_lower for kw in creative_keywords):
            return "creative"
        
        return "fact"
    
    def _generate_result(self, prompt: str, query_type: str) -> str:
        """
        生成查询结果
        
        Args:
            prompt: 查询内容
            query_type: 查询类型
            
        Returns:
            结果文本
        """
        return f"针对 '{prompt}' 的{self.query_types.get(query_type, '查询')}结果"
    
    def _get_verification_suggestions(self, query_type: str) -> list:
        """
        获取验证建议
        
        Args:
            query_type: 查询类型
            
        Returns:
            验证建议列表
        """
        suggestions = {
            "fact": ["交叉验证多个信息源", "查看原始数据来源", "确认时间有效性"],
            "analysis": ["检查逻辑推理链条", "验证前提假设", "考虑反方观点"],
            "creative": ["评估可行性", "对比现有方案", "收集用户反馈"]
        }
        return suggestions.get(query_type, ["多方验证信息准确性"])


path: quick.py
content: #!/usr/bin/env python3
"""
Quick - 快速工具集合
"""

from typing import Dict, Any
import json
import base64
import uuid
import datetime
import re


class QuickTools:
    """快速工具集合类"""
    
    def __init__(self):
        self.available_tools = [
            "json_format", "base64_encode", "base64_decode",
            "uuid_generate", "timestamp_convert", "regex_test",
            "color_convert", "unit_convert"
        ]
    
    def process(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """
        处理快速工具请求
        
        Args:
            prompt: 工具请求
            **kwargs: 其他参数
            
        Returns:
            工具处理结果
        """
        tool_type = self._detect_tool(prompt)
        input_data = kwargs.get("input", "")
        
        result = self._execute_tool(tool_type, input_data)
        
        return {
            "module": "quick",
            "tool": tool_type,
            "input": input_data,
            "result": result,
            "prompt": prompt
        }
    
    def _detect_tool(self, prompt: str) -> str:
        """
        检测需要使用的工具
        
        Args:
            prompt: 用户输入
            
        Returns:
            工具类型
        """
        prompt_lower = prompt.lower()
        
        if any(kw in prompt_lower for kw in ["json", "格式化", "format"]):
            return "json_format"
        elif any(kw in prompt_lower for kw in ["base64", "编码", "encode"]):
            return "base64_encode"
        elif any(kw in prompt_lower for kw in ["解码", "decode"]):
            return "base64_decode"
        elif any(kw in prompt_lower for kw in ["uuid", "唯一", "unique"]):
            return "uuid_generate"
        elif any(kw in prompt_lower for kw in ["时间", "timestamp", "日期"]):
            return "timestamp_convert"
        elif any(kw in prompt_lower for kw in ["正则", "regex", "匹配"]):
            return "regex_test"
        elif any(kw in prompt_lower for kw in ["颜色", "color", "hex", "rgb"]):
            return "color_convert"
        elif any(kw in prompt_lower for kw in ["单位", "unit", "转换"]):
            return "unit_convert"
        
        return "json_format"
    
    def _execute_tool(self, tool_type: str, input_data: str) -> Any:
        """
        执行具体工具
        
        Args:
            tool_type: 工具类型
            input_data: 输入数据
            
        Returns:
            工具执行结果
        """
        tools = {
            "json_format": self._json_format,
            "base64_encode": self._base64_encode,
            "base64_decode": self._base64_decode,
            "uuid_generate": self._uuid_generate,
            "timestamp_convert": self._timestamp_convert,
            "regex_test": self._regex_test,
            "color_convert": self._color_convert,
            "unit_convert": self._unit_convert
        }
        
        tool_func = tools.get(tool_type, lambda x: f"未实现的工具: {tool_type}")
        return tool_func(input_data)
    
    def _json_format(self, data: str) -> str:
        try:
            parsed = json.loads(data)
            return json.dumps(parsed, indent=2, ensure_ascii=False)
        except:
            return "无效的JSON格式"
    
    def _base64_encode(self, data: str) -> str:
        return base64.b64encode(data.encode('utf-8')).decode('utf-8')
    
    def _base64_decode(self, data: str) -> str:
        try:
            return base64.b64decode(data).decode('utf-8')
        except:
            return "无效的Base64编码"
    
    def _uuid_generate(self, _: str) -> str:
        return str(uuid.uuid4())
    
    def _timestamp_convert(self, data: str) -> str:
        try:
            ts = int(data)
            dt = datetime.datetime.fromtimestamp(ts)
            return dt.strftime("%Y-%m-%d %H:%M:%S")
        except:
            now = datetime.datetime.now()
            return f"当前时间: {now.strftime('%Y-%m-%d %H:%M:%S')} (时间戳: {int(now.timestamp())})"
    
    def _regex_test(self, data: str) -> str:
        return f"正则表达式测试: {data}"
    
    def _color_convert(self, data: str) -> str:
        return f"颜色转换: {data}"
    
    def _unit_convert(self, data: str) -> str:
        return f"单位转换: {data}"


path: requirements.txt
content: # Q - 智能多面手工具箱依赖
# Python 3.7+


path: __init__.py
content: """
Q - 智能多面手工具箱
一个集信息查询、创新思维、快速工具、质量保障于一体的全能技能包
"""

from .main import QSkill

__version__ = "1.0.0"
__author__ = "Q Team"
__description__ = "Q = Query + Quantum + Quick + Quality"

__all__ = ["QSkill"]


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (MEDIUM)