ssci-subagent-skills 1.0.0

package/skills/performing-axial-coding/scripts/categories_test.json

@@ -0,0 +1,122 @@
+{
+  "summary": {
+    "total_categories": 1,
+    "total_codes": 20,
+    "core_categories": 1,
+    "top_categories": [
+      "学习"
+    ],
+    "processing_time": 3.98
+  },
+  "details": {
+    "categories": [
+      {
+        "category_id": 0,
+        "codes": [
+          {
+            "concept": "学习",
+            "frequency": 7,
+            "type": "一般概念"
+          },
+          {
+            "concept": "大学",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "遇到",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "很多",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "困难",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "我会",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "老师",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "帮助",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "通过",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "能够",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "更好",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "生活",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "学会",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "如何",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "自己",
+            "frequency": 2,
+            "type": "一般概念"
+          },
+          {
+            "concept": "问题",
+            "frequency": 1,
+            "type": "一般概念"
+          },
+          {
+            "concept": "主动",
+            "frequency": 1,
+            "type": "一般概念"
+          }
+        ],
+        "size": 17,
+        "total_frequency": 37,
+        "name": "学习",
+        "definition": "涉及学习, 大学, 遇到等相关概念的范畴",
+        "importance": 1.0
+      }
+    ],
+    "hierarchy": {
+      "core": [
+        0
+      ],
+      "secondary": [],
+      "hierarchy_type": "frequency_based"
+    }
+  },
+  "metadata": {
+    "input_file": "D:\\stigmergy-CLI-Multi-Agents\\sscisubagent-skills\\skills\\coding\\performing-axial-coding\\scripts\\..\\..\\performing-open-coding\\scripts\\concepts_test.json",
+    "timestamp": "2025-12-19T11:06:55.075407",
+    "version": "1.0.0"
+  }
+}

package/skills/performing-axial-coding/scripts/construct_paradigm.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Paradigm模型构建脚本 - 轴心编码
+
+功能：
+- 识别条件维度
+- 识别行动/互动
+- 识别结果维度
+- 构建完整Paradigm模型
+
+使用方式：
+  python construct_paradigm.py --input relationships.json --output paradigm.json
+"""
+
+import argparse
+import json
+import logging
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict
+
+logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+
+def identify_conditions(categories: List[Dict], relations: List[Dict]) -> List[str]:
+    """
+    识别条件维度
+    
+    策略：查找作为因果关系源头的范畴
+    
+    Returns:
+        条件范畴列表
+    """
+    conditions = []
+    
+    # 查找条件关系
+    conditional_sources = [r['source'] for r in relations if r['type'] == 'CONDITIONAL']
+    
+    # 查找因果关系的源头
+    causal_sources = [r['source'] for r in relations if r['type'] == 'CAUSAL']
+    
+    # 合并并去重
+    all_conditions = set(conditional_sources + causal_sources)
+    
+    return list(all_conditions)
+
+def identify_actions(categories: List[Dict], relations: List[Dict]) -> List[str]:
+    """
+    识别行动/互动维度
+    
+    策略：查找策略关系的范畴
+    
+    Returns:
+        行动范畴列表
+    """
+    actions = []
+    
+    # 查找策略关系
+    strategy_categories = [r['category'] for r in relations if r['type'] == 'STRATEGY']
+    
+    # 查找互动关系
+    interaction_categories = []
+    for r in relations:
+        if r['type'] == 'INTERACTION':
+            interaction_categories.extend([r['source'], r['target']])
+    
+    # 合并并去重
+    all_actions = set(strategy_categories + interaction_categories)
+    
+    return list(all_actions)
+
+def identify_consequences(categories: List[Dict], relations: List[Dict]) -> List[str]:
+    """
+    识别结果维度
+    
+    策略：查找作为因果关系目标的范畴
+    
+    Returns:
+        结果范畴列表
+    """
+    consequences = []
+    
+    # 查找因果关系的目标
+    causal_targets = [r['target'] for r in relations if r['type'] == 'CAUSAL']
+    
+    return list(set(causal_targets))
+
+def identify_phenomenon(categories: List[Dict], relations: List[Dict]) -> str:
+    """
+    识别核心现象
+    
+    策略：选择连接最多的范畴
+    
+    Returns:
+        核心现象范畴名称
+    """
+    if not relations:
+        # 如果没有关系，选择频率最高的范畴
+        return max(categories, key=lambda c: c.get('total_frequency', 0))['name']
+    
+    # 统计每个范畴的连接数
+    category_connections = {}
+    for rel in relations:
+        if 'source' in rel:
+            category_connections[rel['source']] = category_connections.get(rel['source'], 0) + 1
+        if 'target' in rel:
+            category_connections[rel['target']] = category_connections.get(rel['target'], 0) + 1
+    
+    # 选择连接最多的
+    if category_connections:
+        phenomenon = max(category_connections.items(), key=lambda x: x[1])[0]
+        return phenomenon
+    
+    return categories[0]['name'] if categories else "未识别"
+
+def build_paradigm_model(categories: List[Dict], relations: List[Dict]) -> Dict:
+    """
+    构建完整Paradigm模型
+    
+    Returns:
+        Paradigm模型字典
+    """
+    # 识别核心现象
+    phenomenon = identify_phenomenon(categories, relations)
+    
+    # 识别各维度
+    conditions = identify_conditions(categories, relations)
+    actions = identify_actions(categories, relations)
+    consequences = identify_consequences(categories, relations)
+    
+    # 识别语境（不在条件、行动、结果中的范畴）
+    all_categories = set(c['name'] for c in categories)
+    used_categories = set(conditions + actions + consequences + [phenomenon])
+    context = list(all_categories - used_categories)
+    
+    return {
+        'phenomenon': phenomenon,
+        'causal_conditions': conditions,
+        'context': context,
+        'intervening_conditions': [],  # 需要更复杂的分析
+        'action_strategies': actions,
+        'consequences': consequences
+    }
+
+def validate_paradigm(model: Dict) -> Dict:
+    """
+    验证Paradigm模型完整性
+    
+    Returns:
+        验证结果
+    """
+    issues = []
+    
+    if not model['phenomenon']:
+        issues.append("缺少核心现象")
+    
+    if not model['causal_conditions']:
+        issues.append("缺少因果条件")
+    
+    if not model['action_strategies']:
+        issues.append("缺少行动策略")
+    
+    if not model['consequences']:
+        issues.append("缺少结果维度")
+    
+    completeness = 1.0 - (len(issues) / 4.0)
+    
+    return {
+        'is_complete': len(issues) == 0,
+        'completeness_score': round(completeness, 2),
+        'issues': issues
+    }
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Paradigm模型构建工具 - 轴心编码',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例用法:
+  python construct_paradigm.py --input relationships.json --output paradigm.json
+        """
+    )
+    parser.add_argument('--input', '-i', required=True, help='输入的关系JSON文件')
+    parser.add_argument('--output', '-o', default='paradigm.json', help='输出JSON文件')
+    args = parser.parse_args()
+    
+    start_time = time.time()
+    
+    try:
+        # 读取关系数据
+        input_path = Path(args.input)
+        if not input_path.exists():
+            logging.error(f"文件不存在: {args.input}")
+            sys.exit(1)
+        
+        with open(input_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # 提取范畴和关系
+        if 'details' not in data:
+            logging.error("数据格式错误：缺少details字段")
+            sys.exit(2)
+        
+        # 从之前的categories.json读取范畴
+        categories_file = input_path.parent / 'categories_test.json'
+        if categories_file.exists():
+            with open(categories_file, 'r', encoding='utf-8') as f:
+                cat_data = json.load(f)
+                categories = cat_data.get('details', {}).get('categories', [])
+        else:
+            categories = []
+        
+        # 提取关系
+        all_relations = []
+        for rel_type in ['causal_relations', 'conditional_relations', 'interaction_relations']:
+            if rel_type in data['details']:
+                all_relations.extend(data['details'][rel_type])
+        
+        logging.info(f"✓ 读取关系: {len(all_relations)} 个")
+        logging.info(f"✓ 读取范畴: {len(categories)} 个")
+        
+        # 构建Paradigm模型
+        paradigm = build_paradigm_model(categories, all_relations)
+        
+        # 验证模型
+        validation = validate_paradigm(paradigm)
+        
+        processing_time = time.time() - start_time
+        
+        # 构建输出
+        output = {
+            'summary': {
+                'phenomenon': paradigm['phenomenon'],
+                'conditions_count': len(paradigm['causal_conditions']),
+                'actions_count': len(paradigm['action_strategies']),
+                'consequences_count': len(paradigm['consequences']),
+                'completeness': validation['completeness_score'],
+                'processing_time': round(processing_time, 2)
+            },
+            'details': {
+                'paradigm': paradigm,
+                'validation': validation
+            },
+            'metadata': {
+                'input_file': str(input_path.absolute()),
+                'timestamp': datetime.now().isoformat(),
+                'version': '1.0.0'
+            }
+        }
+        
+        # 保存
+        with open(args.output, 'w', encoding='utf-8') as f:
+            json.dump(output, f, ensure_ascii=False, indent=2)
+        
+        logging.info(f"✅ Paradigm构建完成")
+        logging.info(f"   核心现象: {paradigm['phenomenon']}")
+        logging.info(f"   完整度: {validation['completeness_score']*100:.0f}%")
+        if validation['issues']:
+            logging.warning(f"   问题: {', '.join(validation['issues'])}")
+        logging.info(f"📄 详细结果: {args.output}")
+        
+    except Exception as e:
+        logging.error(f"处理失败: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(99)
+
+if __name__ == "__main__":
+    main()

package/skills/performing-axial-coding/scripts/identify_categories.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+范畴识别脚本 - 轴心编码
+
+功能：
+- 从开放编码结果聚类为范畴
+- 范畴命名和定义
+- 构建范畴层级
+
+使用方式：
+  python identify_categories.py --input codes.json --output categories.json
+"""
+
+import argparse
+import json
+import logging
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict
+from collections import Counter
+import numpy as np
+from sklearn.cluster import KMeans, AgglomerativeClustering
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+
+def cluster_codes_to_categories(codes: List[Dict], n_categories: int = None, min_codes: int = 3) -> List[Dict]:
+    """
+    将编码聚类为范畴
+    
+    Args:
+        codes: 编码列表
+        n_categories: 范畴数量（None则自动确定）
+        min_codes: 每个范畴最少编码数
+    
+    Returns:
+        范畴列表
+    """
+    if len(codes) < min_codes:
+        raise ValueError(f"编码数量不足（至少需要{min_codes}个）")
+    
+    # 自动确定范畴数
+    if n_categories is None:
+        n_categories = max(2, min(len(codes) // 5, 15))
+        logging.info(f"自动确定范畴数: {n_categories}")
+    
+    # 提取编码文本
+    code_texts = [c.get('concept') or c.get('code', '') for c in codes]
+    
+    # 使用TF-IDF向量化（简单实现，不依赖jieba）
+    vectorizer = TfidfVectorizer(max_features=100)
+    try:
+        tfidf_matrix = vectorizer.fit_transform(code_texts)
+    except Exception as e:
+        logging.error(f"向量化失败: {e}")
+        raise
+    
+    # K-means聚类
+    kmeans = KMeans(n_clusters=n_categories, random_state=42, n_init=10)
+    labels = kmeans.fit_predict(tfidf_matrix)
+    
+    # 组织范畴
+    category_groups = {}
+    for i, label in enumerate(labels):
+        label = int(label)
+        if label not in category_groups:
+            category_groups[label] = []
+        category_groups[label].append(codes[i])
+    
+    # 过滤小范畴
+    categories = []
+    for cat_id, cat_codes in category_groups.items():
+        if len(cat_codes) >= min_codes:
+            category = {
+                'category_id': cat_id,
+                'codes': cat_codes,
+                'size': len(cat_codes),
+                'total_frequency': sum(c.get('frequency', 1) for c in cat_codes)
+            }
+            categories.append(category)
+    
+    return sorted(categories, key=lambda x: x['total_frequency'], reverse=True)
+
+def name_category(codes: List[Dict]) -> str:
+    """
+    为范畴命名
+    
+    策略：使用最高频编码作为范畴名
+    
+    Returns:
+        范畴名称
+    """
+    if not codes:
+        return "未命名范畴"
+    
+    # 选择频率最高的编码
+    top_code = max(codes, key=lambda c: c.get('frequency', 1))
+    return top_code.get('concept') or top_code.get('code', '未命名')
+
+def define_category(codes: List[Dict]) -> str:
+    """
+    定义范畴
+    
+    策略：综合所有编码的定义
+    
+    Returns:
+        范畴定义
+    """
+    if not codes:
+        return ""
+    
+    # 提取所有编码的关键词
+    all_words = []
+    for code in codes:
+        concept = code.get('concept') or code.get('code', '')
+        all_words.extend(concept.split())
+    
+    # 统计高频词
+    word_freq = Counter(all_words)
+    top_words = [w for w, _ in word_freq.most_common(5)]
+    
+    # 生成定义
+    definition = f"涉及{', '.join(top_words[:3])}等相关概念的范畴"
+    return definition
+
+def build_category_hierarchy(categories: List[Dict]) -> Dict:
+    """
+    构建范畴层级结构
+    
+    策略：基于包含关系和频率
+    
+    Returns:
+        层级结构字典
+    """
+    # 简单实现：按频率分为核心范畴和次要范畴
+    total_freq = sum(c['total_frequency'] for c in categories)
+    
+    core_categories = []
+    secondary_categories = []
+    
+    for category in categories:
+        proportion = category['total_frequency'] / total_freq
+        if proportion > 0.15:  # 占比>15%为核心范畴
+            core_categories.append(category['category_id'])
+        else:
+            secondary_categories.append(category['category_id'])
+    
+    return {
+        'core': core_categories,
+        'secondary': secondary_categories,
+        'hierarchy_type': 'frequency_based'
+    }
+
+def calculate_category_importance(categories: List[Dict]) -> List[Dict]:
+    """
+    计算范畴重要性
+    
+    Returns:
+        添加了importance字段的范畴列表
+    """
+    total_freq = sum(c['total_frequency'] for c in categories)
+    
+    for category in categories:
+        category['importance'] = round(category['total_frequency'] / total_freq, 3)
+    
+    return categories
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='范畴识别工具 - 轴心编码',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例用法:
+  python identify_categories.py --input codes.json --output categories.json
+  python identify_categories.py -i codes.json -o result.json --n-categories 8
+        """
+    )
+    parser.add_argument('--input', '-i', required=True, help='输入的编码JSON文件')
+    parser.add_argument('--output', '-o', default='categories.json', help='输出JSON文件')
+    parser.add_argument('--n-categories', '-n', type=int, help='范畴数量（默认自动确定）')
+    parser.add_argument('--min-codes', type=int, default=3, help='每个范畴最少编码数（默认：3）')
+    args = parser.parse_args()
+    
+    start_time = time.time()
+    
+    try:
+        # 读取编码数据
+        input_path = Path(args.input)
+        if not input_path.exists():
+            logging.error(f"文件不存在: {args.input}")
+            sys.exit(1)
+        
+        with open(input_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # 提取编码列表
+        if 'details' in data and 'concepts' in data['details']:
+            codes = data['details']['concepts']
+        elif isinstance(data, list):
+            codes = data
+        else:
+            logging.error("无法识别的数据格式")
+            sys.exit(2)
+        
+        if len(codes) < args.min_codes:
+            logging.error(f"编码数量不足（至少需要{args.min_codes}个）")
+            sys.exit(3)
+        
+        logging.info(f"✓ 读取编码: {len(codes)} 个")
+        
+        # 聚类为范畴
+        categories = cluster_codes_to_categories(codes, args.n_categories, args.min_codes)
+        
+        # 为每个范畴命名和定义
+        for category in categories:
+            category['name'] = name_category(category['codes'])
+            category['definition'] = define_category(category['codes'])
+        
+        # 计算重要性
+        categories = calculate_category_importance(categories)
+        
+        # 构建层级
+        hierarchy = build_category_hierarchy(categories)
+        
+        processing_time = time.time() - start_time
+        
+        # 构建输出
+        output = {
+            'summary': {
+                'total_categories': len(categories),
+                'total_codes': len(codes),
+                'core_categories': len(hierarchy['core']),
+                'top_categories': [c['name'] for c in categories[:5]],
+                'processing_time': round(processing_time, 2)
+            },
+            'details': {
+                'categories': categories,
+                'hierarchy': hierarchy
+            },
+            'metadata': {
+                'input_file': str(input_path.absolute()),
+                'timestamp': datetime.now().isoformat(),
+                'version': '1.0.0'
+            }
+        }
+        
+        # 保存
+        with open(args.output, 'w', encoding='utf-8') as f:
+            json.dump(output, f, ensure_ascii=False, indent=2)
+        
+        logging.info(f"✅ 范畴识别完成")
+        logging.info(f"   识别范畴: {len(categories)} 个")
+        logging.info(f"   核心范畴: {len(hierarchy['core'])} 个")
+        logging.info(f"   主要范畴: {', '.join([c['name'] for c in categories[:3]])}")
+        logging.info(f"📄 详细结果: {args.output}")
+        
+    except Exception as e:
+        logging.error(f"处理失败: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(99)
+
+if __name__ == "__main__":
+    main()