clearai-dsh 0.1.0

package/presets/clearai/template/skills/citation-management/scripts/validate_citations.py

@@ -0,0 +1,497 @@
+#!/usr/bin/env python3
+"""
+Citation Validation Tool
+Validate BibTeX files for accuracy, completeness, and format compliance.
+"""
+
+import sys
+import re
+import requests
+import argparse
+import json
+from typing import Dict, List, Tuple, Optional
+from collections import defaultdict
+
+class CitationValidator:
+    """Validate BibTeX entries for errors and inconsistencies."""
+    
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'CitationValidator/1.0 (Citation Management Tool)'
+        })
+        
+        # Required fields by entry type
+        self.required_fields = {
+            'article': ['author', 'title', 'journal', 'year'],
+            'book': ['title', 'publisher', 'year'],  # author OR editor
+            'inproceedings': ['author', 'title', 'booktitle', 'year'],
+            'incollection': ['author', 'title', 'booktitle', 'publisher', 'year'],
+            'phdthesis': ['author', 'title', 'school', 'year'],
+            'mastersthesis': ['author', 'title', 'school', 'year'],
+            'techreport': ['author', 'title', 'institution', 'year'],
+            'misc': ['title', 'year']
+        }
+        
+        # Recommended fields
+        self.recommended_fields = {
+            'article': ['volume', 'pages', 'doi'],
+            'book': ['isbn'],
+            'inproceedings': ['pages'],
+        }
+    
+    def parse_bibtex_file(self, filepath: str) -> List[Dict]:
+        """
+        Parse BibTeX file and extract entries.
+        
+        Args:
+            filepath: Path to BibTeX file
+            
+        Returns:
+            List of entry dictionaries
+        """
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except Exception as e:
+            print(f'Error reading file: {e}', file=sys.stderr)
+            return []
+        
+        entries = []
+        
+        # Match BibTeX entries
+        pattern = r'@(\w+)\s*\{\s*([^,\s]+)\s*,(.*?)\n\}'
+        matches = re.finditer(pattern, content, re.DOTALL | re.IGNORECASE)
+        
+        for match in matches:
+            entry_type = match.group(1).lower()
+            citation_key = match.group(2).strip()
+            fields_text = match.group(3)
+            
+            # Parse fields
+            fields = {}
+            field_pattern = r'(\w+)\s*=\s*\{([^}]*)\}|(\w+)\s*=\s*"([^"]*)"'
+            field_matches = re.finditer(field_pattern, fields_text)
+            
+            for field_match in field_matches:
+                if field_match.group(1):
+                    field_name = field_match.group(1).lower()
+                    field_value = field_match.group(2)
+                else:
+                    field_name = field_match.group(3).lower()
+                    field_value = field_match.group(4)
+                
+                fields[field_name] = field_value.strip()
+            
+            entries.append({
+                'type': entry_type,
+                'key': citation_key,
+                'fields': fields,
+                'raw': match.group(0)
+            })
+        
+        return entries
+    
+    def validate_entry(self, entry: Dict) -> Tuple[List[Dict], List[Dict]]:
+        """
+        Validate a single BibTeX entry.
+        
+        Args:
+            entry: Entry dictionary
+            
+        Returns:
+            Tuple of (errors, warnings)
+        """
+        errors = []
+        warnings = []
+        
+        entry_type = entry['type']
+        key = entry['key']
+        fields = entry['fields']
+        
+        # Check required fields
+        if entry_type in self.required_fields:
+            for req_field in self.required_fields[entry_type]:
+                if req_field not in fields or not fields[req_field]:
+                    # Special case: book can have author OR editor
+                    if entry_type == 'book' and req_field == 'author':
+                        if 'editor' not in fields or not fields['editor']:
+                            errors.append({
+                                'type': 'missing_required_field',
+                                'field': 'author or editor',
+                                'severity': 'high',
+                                'message': f'Entry {key}: Missing required field "author" or "editor"'
+                            })
+                    else:
+                        errors.append({
+                            'type': 'missing_required_field',
+                            'field': req_field,
+                            'severity': 'high',
+                            'message': f'Entry {key}: Missing required field "{req_field}"'
+                        })
+        
+        # Check recommended fields
+        if entry_type in self.recommended_fields:
+            for rec_field in self.recommended_fields[entry_type]:
+                if rec_field not in fields or not fields[rec_field]:
+                    warnings.append({
+                        'type': 'missing_recommended_field',
+                        'field': rec_field,
+                        'severity': 'medium',
+                        'message': f'Entry {key}: Missing recommended field "{rec_field}"'
+                    })
+        
+        # Validate year
+        if 'year' in fields:
+            year = fields['year']
+            if not re.match(r'^\d{4}$', year):
+                errors.append({
+                    'type': 'invalid_year',
+                    'field': 'year',
+                    'value': year,
+                    'severity': 'high',
+                    'message': f'Entry {key}: Invalid year format "{year}" (should be 4 digits)'
+                })
+            elif int(year) < 1600 or int(year) > 2030:
+                warnings.append({
+                    'type': 'suspicious_year',
+                    'field': 'year',
+                    'value': year,
+                    'severity': 'medium',
+                    'message': f'Entry {key}: Suspicious year "{year}" (outside reasonable range)'
+                })
+        
+        # Validate DOI format
+        if 'doi' in fields:
+            doi = fields['doi']
+            if not re.match(r'^10\.\d{4,}/[^\s]+$', doi):
+                warnings.append({
+                    'type': 'invalid_doi_format',
+                    'field': 'doi',
+                    'value': doi,
+                    'severity': 'medium',
+                    'message': f'Entry {key}: Invalid DOI format "{doi}"'
+                })
+        
+        # Check for single hyphen in pages (should be --)
+        if 'pages' in fields:
+            pages = fields['pages']
+            if re.search(r'\d-\d', pages) and '--' not in pages:
+                warnings.append({
+                    'type': 'page_range_format',
+                    'field': 'pages',
+                    'value': pages,
+                    'severity': 'low',
+                    'message': f'Entry {key}: Page range uses single hyphen, should use -- (en-dash)'
+                })
+        
+        # Check author format
+        if 'author' in fields:
+            author = fields['author']
+            if ';' in author or '&' in author:
+                errors.append({
+                    'type': 'invalid_author_format',
+                    'field': 'author',
+                    'severity': 'high',
+                    'message': f'Entry {key}: Authors should be separated by " and ", not ";" or "&"'
+                })
+        
+        return errors, warnings
+    
+    def verify_doi(self, doi: str) -> Tuple[bool, Optional[Dict]]:
+        """
+        Verify DOI resolves correctly and get metadata.
+        
+        Args:
+            doi: Digital Object Identifier
+            
+        Returns:
+            Tuple of (is_valid, metadata)
+        """
+        try:
+            url = f'https://doi.org/{doi}'
+            response = self.session.head(url, timeout=10, allow_redirects=True)
+            
+            if response.status_code < 400:
+                # DOI resolves, now get metadata from CrossRef
+                crossref_url = f'https://api.crossref.org/works/{doi}'
+                metadata_response = self.session.get(crossref_url, timeout=10)
+                
+                if metadata_response.status_code == 200:
+                    data = metadata_response.json()
+                    message = data.get('message', {})
+                    
+                    # Extract key metadata
+                    metadata = {
+                        'title': message.get('title', [''])[0],
+                        'year': self._extract_year_crossref(message),
+                        'authors': self._format_authors_crossref(message.get('author', [])),
+                    }
+                    return True, metadata
+                else:
+                    return True, None  # DOI resolves but no CrossRef metadata
+            else:
+                return False, None
+                
+        except Exception:
+            return False, None
+    
+    def detect_duplicates(self, entries: List[Dict]) -> List[Dict]:
+        """
+        Detect duplicate entries.
+        
+        Args:
+            entries: List of entry dictionaries
+            
+        Returns:
+            List of duplicate groups
+        """
+        duplicates = []
+        
+        # Check for duplicate DOIs
+        doi_map = defaultdict(list)
+        for entry in entries:
+            doi = entry['fields'].get('doi', '').strip()
+            if doi:
+                doi_map[doi].append(entry['key'])
+        
+        for doi, keys in doi_map.items():
+            if len(keys) > 1:
+                duplicates.append({
+                    'type': 'duplicate_doi',
+                    'doi': doi,
+                    'entries': keys,
+                    'severity': 'high',
+                    'message': f'Duplicate DOI {doi} found in entries: {", ".join(keys)}'
+                })
+        
+        # Check for duplicate citation keys
+        key_counts = defaultdict(int)
+        for entry in entries:
+            key_counts[entry['key']] += 1
+        
+        for key, count in key_counts.items():
+            if count > 1:
+                duplicates.append({
+                    'type': 'duplicate_key',
+                    'key': key,
+                    'count': count,
+                    'severity': 'high',
+                    'message': f'Citation key "{key}" appears {count} times'
+                })
+        
+        # Check for similar titles (possible duplicates)
+        titles = {}
+        for entry in entries:
+            title = entry['fields'].get('title', '').lower()
+            title = re.sub(r'[^\w\s]', '', title)  # Remove punctuation
+            title = ' '.join(title.split())  # Normalize whitespace
+            
+            if title:
+                if title in titles:
+                    duplicates.append({
+                        'type': 'similar_title',
+                        'entries': [titles[title], entry['key']],
+                        'severity': 'medium',
+                        'message': f'Possible duplicate: "{titles[title]}" and "{entry["key"]}" have identical titles'
+                    })
+                else:
+                    titles[title] = entry['key']
+        
+        return duplicates
+    
+    def validate_file(self, filepath: str, check_dois: bool = False) -> Dict:
+        """
+        Validate entire BibTeX file.
+        
+        Args:
+            filepath: Path to BibTeX file
+            check_dois: Whether to verify DOIs (slow)
+            
+        Returns:
+            Validation report dictionary
+        """
+        print(f'Parsing {filepath}...', file=sys.stderr)
+        entries = self.parse_bibtex_file(filepath)
+        
+        if not entries:
+            return {
+                'total_entries': 0,
+                'errors': [],
+                'warnings': [],
+                'duplicates': []
+            }
+        
+        print(f'Found {len(entries)} entries', file=sys.stderr)
+        
+        all_errors = []
+        all_warnings = []
+        
+        # Validate each entry
+        for i, entry in enumerate(entries):
+            print(f'Validating entry {i+1}/{len(entries)}: {entry["key"]}', file=sys.stderr)
+            errors, warnings = self.validate_entry(entry)
+            
+            for error in errors:
+                error['entry'] = entry['key']
+                all_errors.append(error)
+            
+            for warning in warnings:
+                warning['entry'] = entry['key']
+                all_warnings.append(warning)
+        
+        # Check for duplicates
+        print('Checking for duplicates...', file=sys.stderr)
+        duplicates = self.detect_duplicates(entries)
+        
+        # Verify DOIs if requested
+        doi_errors = []
+        if check_dois:
+            print('Verifying DOIs...', file=sys.stderr)
+            for i, entry in enumerate(entries):
+                doi = entry['fields'].get('doi', '')
+                if doi:
+                    print(f'Verifying DOI {i+1}: {doi}', file=sys.stderr)
+                    is_valid, metadata = self.verify_doi(doi)
+                    
+                    if not is_valid:
+                        doi_errors.append({
+                            'type': 'invalid_doi',
+                            'entry': entry['key'],
+                            'doi': doi,
+                            'severity': 'high',
+                            'message': f'Entry {entry["key"]}: DOI does not resolve: {doi}'
+                        })
+        
+        all_errors.extend(doi_errors)
+        
+        return {
+            'filepath': filepath,
+            'total_entries': len(entries),
+            'valid_entries': len(entries) - len([e for e in all_errors if e['severity'] == 'high']),
+            'errors': all_errors,
+            'warnings': all_warnings,
+            'duplicates': duplicates
+        }
+    
+    def _extract_year_crossref(self, message: Dict) -> str:
+        """Extract year from CrossRef message."""
+        date_parts = message.get('published-print', {}).get('date-parts', [[]])
+        if not date_parts or not date_parts[0]:
+            date_parts = message.get('published-online', {}).get('date-parts', [[]])
+        
+        if date_parts and date_parts[0]:
+            return str(date_parts[0][0])
+        return ''
+    
+    def _format_authors_crossref(self, authors: List[Dict]) -> str:
+        """Format author list from CrossRef."""
+        if not authors:
+            return ''
+        
+        formatted = []
+        for author in authors[:3]:  # First 3 authors
+            given = author.get('given', '')
+            family = author.get('family', '')
+            if family:
+                formatted.append(f'{family}, {given}' if given else family)
+        
+        if len(authors) > 3:
+            formatted.append('et al.')
+        
+        return ', '.join(formatted)
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(
+        description='Validate BibTeX files for errors and inconsistencies',
+        epilog='Example: python validate_citations.py references.bib'
+    )
+    
+    parser.add_argument(
+        'file',
+        help='BibTeX file to validate'
+    )
+    
+    parser.add_argument(
+        '--check-dois',
+        action='store_true',
+        help='Verify DOIs resolve correctly (slow)'
+    )
+    
+    parser.add_argument(
+        '--auto-fix',
+        action='store_true',
+        help='Attempt to auto-fix common issues (not implemented yet)'
+    )
+    
+    parser.add_argument(
+        '--report',
+        help='Output file for JSON validation report'
+    )
+    
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='Show detailed output'
+    )
+    
+    args = parser.parse_args()
+    
+    # Validate file
+    validator = CitationValidator()
+    report = validator.validate_file(args.file, check_dois=args.check_dois)
+    
+    # Print summary
+    print('\n' + '='*60)
+    print('CITATION VALIDATION REPORT')
+    print('='*60)
+    print(f'\nFile: {args.file}')
+    print(f'Total entries: {report["total_entries"]}')
+    print(f'Valid entries: {report["valid_entries"]}')
+    print(f'Errors: {len(report["errors"])}')
+    print(f'Warnings: {len(report["warnings"])}')
+    print(f'Duplicates: {len(report["duplicates"])}')
+    
+    # Print errors
+    if report['errors']:
+        print('\n' + '-'*60)
+        print('ERRORS (must fix):')
+        print('-'*60)
+        for error in report['errors']:
+            print(f'\n{error["message"]}')
+            if args.verbose:
+                print(f'  Type: {error["type"]}')
+                print(f'  Severity: {error["severity"]}')
+    
+    # Print warnings
+    if report['warnings'] and args.verbose:
+        print('\n' + '-'*60)
+        print('WARNINGS (should fix):')
+        print('-'*60)
+        for warning in report['warnings']:
+            print(f'\n{warning["message"]}')
+    
+    # Print duplicates
+    if report['duplicates']:
+        print('\n' + '-'*60)
+        print('DUPLICATES:')
+        print('-'*60)
+        for dup in report['duplicates']:
+            print(f'\n{dup["message"]}')
+    
+    # Save report
+    if args.report:
+        with open(args.report, 'w', encoding='utf-8') as f:
+            json.dump(report, f, indent=2)
+        print(f'\nDetailed report saved to: {args.report}')
+    
+    # Exit with error code if there are errors
+    if report['errors']:
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()
+

package/presets/clearai/template/skills/data-analysis/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: data-analysis
+description: |
+  【数据·深度分析】数据生成过程还原、机理关联、领域知识提取与质量审计。适用：已了解数据结构后的深度分析。不适用：首次拿到未知数据文件（用 exploratory-data-analysis）；流程型系统专项 QA（用 data-qa-analysis）。
+version: '1.0'
+metadata:
+  tier: system
+  origin: template
+  created_at: '2026-06-12T02:47:05.407046+00:00'
+---
+
+# 数据深度分析 Skill (SOP)
+
+> 本 Skill 旨在将数据分析提升至领域专家水平。你不再是一个简单的统计员，而是**资深数据分析专家**。
+
+## 使用边界
+
+- **适用**：数据结构已初步了解后的深度分析（生成过程还原、机理关联、领域知识）。
+- **不适用**：首次未知数据文件 → `exploratory-data-analysis`；流程型系统专项 → `data-qa-analysis`；纯统计检验 → `statistical-analysis`。
+
+## 落盘约定
+
+- **过程脚本**：`lab/scripts/`（探索性分析、绘图）
+- **交付目录**：`products/extracted/`（结构化产物与报告）
+  - `products/extracted/tag_entity_map.json`（变量→实体映射；**禁止**写入 `entity_map.json`，该路径保留给流程拓扑 skill）
+  - `products/extracted/data_dictionary.md`
+  - `products/extracted/feature_candidates.json`
+  - `products/extracted/expert_rules.json`
+  - `products/extracted/cleaning_rules.yaml`
+  - `products/extracted/data_quality_report.md`
+  - `products/extracted/domain_knowledge.md`
+  - `products/extracted/analysis_report.md`
+- 填写 `templates/domain_knowledge_template.md.tpl` 时，内容须汇总写入 `products/extracted/domain_knowledge.md`
+
+## 1. 核心方法论 (The Four Lenses)
+你的分析必须贯穿以下四个维度（Meta-Knowledge）：
+- **Process (过程)**: 还原数据生成过程，识别运行/实验模式，评估过程稳定性。
+- **Quality (质量)**: 审计数据质量，校验机理与单位一致性，关联异常与缺陷。
+- **Cost (代价)**: 识别隐性的信息损失与采集代价，量化异常的影响。
+- **Continuity (连续性)**: 分析时间序列的连续性，识别中断与效率瓶颈。
+
+## 2. 决策树 (Decision Tree)
+根据用户意图选择子流程：
+1. **"理解这份数据 / 还原数据生成过程"** -> `workflows/01-data-profiling.md` (深度画像与过程还原)
+2. **"数据质量如何 / 能否物理自洽"** -> `workflows/02-quality-audit.md` (时序对齐与机理校验)
+3. **"寻找因果关系 / 挖掘特征"** -> `workflows/03-physical-correlation.md` (滞后分析与因果发现)
+4. **"分析日志 / 提取专家经验"** -> `workflows/04-unstructured-mining.md` (非结构化挖掘)
+5. **"全面体检"** -> 按顺序执行 1 -> 2 -> 3 -> 4，最后基于 `templates/analysis_report.md.tpl` 生成 `products/extracted/analysis_report.md`。
+
+## 3. 核心指令 (Core Instructions)
+
+<instruction>
+<role>
+你是顶尖研究机构级别的数据分析专家。你不仅仅看数字，你看到的是数字背后真实运转的系统：流动的物质、变化的状态和演化的过程。你对时间戳极其敏感，对量纲与单位一丝不苟。
+</role>
+
+<rule>
+1. **机理优先 (Mechanism-First)**: 
+   - 严禁在未确认单位的情况下计算统计量。
+   - 必须检查机理一致性（如：守恒量是否平衡？比例是否越界？）。
+2. **过程还原 (Process Reconstruction)**: 
+   - 不要把数据看作静态表格，而要看作动态过程的快照。
+   - 尝试通过数据还原出 "输入 -> 处理 -> 输出" 的时序逻辑。
+3. **知识资产化**: 
+   - 所有发现须汇总到 `products/extracted/domain_knowledge.md`（结构参考 `templates/domain_knowledge_template.md.tpl`）。
+   - 必须区分 "硬性约束" (Mechanism) 和 "软性规则" (Heuristics)。
+4. **先读后算**：统计缺失率、采样间隔、相关系数、稳定性指标前，必须 read 或 bash 读取 `input/` 下实际文件；未取证前不得写出具体数字。
+5. **变量必须存在**：`products/extracted/tag_entity_map.json` 中的变量/列名必须来自已读取数据的表头或字典，禁止凭命名惯例虚构变量。
+6. **报告数值带来源**：`products/extracted/data_quality_report.md` / `products/extracted/analysis_report.md` 中每个量化结论附 `来源: <path>`。
+</rule>
+
+<thinking>
+在执行每一步前，强制进行 Chain-of-Thought：
+1. 这个变量在真实世界中对应什么实体？（观测通道？控制输入？）
+2. 这段数据的变化趋势是否符合领域常识？
+3. 如果我不理解这个异常，是否可以通过时间轴关联到其他变量？
+4. 我提取的这条规则，在实践中是否可执行、可验证？
+</thinking>
+</instruction>
+
+## 4. 资源索引 (Resource Index)
+- **Workflows**:
+  - `workflows/01-data-profiling.md`
+  - `workflows/02-quality-audit.md`
+  - `workflows/03-physical-correlation.md`
+  - `workflows/04-unstructured-mining.md`
+- **Templates**:
+  - `templates/domain_knowledge_template.md.tpl` (核心)
+  - `templates/analysis_report.md.tpl`
+  - `templates/data_dictionary.md.tpl`
+- **Checklists**:
+  - `checklists/readiness_check.md`

package/presets/clearai/template/skills/data-analysis/checklists/readiness_check.md

@@ -0,0 +1,23 @@
+# 建模准入自检清单 (Readiness Checklist)
+
+> 在宣布分析完成并建议进入 Modeling 阶段前，必须通过以下所有检查。
+
+## 1. 物理语义自检
+- [ ] 所有字段的 **物理单位** 已确认且合理（如：没有出现“负的绝对温度”）。
+- [ ] 已识别出 **Business Keys**（如批次号、样本编号、会话 ID），并验证了其唯一性。
+- [ ] 已确认数据的 **采样频率**，并评估其是否足以捕捉目标过程（奈奎斯特定理）。
+
+## 2. 数据质量自检
+- [ ] **Data Dictionary** 已生成且完整。
+- [ ] `products/extracted/data_quality_report.md` 已生成，且无致命数据质量缺陷。
+- [ ] 所有识别出的异常模式（卡死、丢包）都有对应的 **Cleaning Rule** 建议。
+
+## 3. 建模可行性自检
+- [ ] 已识别出至少 1 个 **Target** (预测目标) 和 3 个以上的强相关 **Features**。
+- [ ] 已评估数据量是否满足建模需求（如：复杂模型至少需要 1000+ 样本）。
+- [ ] 已明确区分 **训练集** 和 **测试集** 的划分策略（如：按时间切分，而非随机 Shuffle）。
+
+## 4. 交付物完整性
+- [ ] `products/extracted/domain_knowledge.md` 已汇总各 workflow 章节
+- [ ] `products/extracted/analysis_report.md` 包含四大维度视角的分析结论。
+- [ ] `products/extracted/feature_candidates.json` 包含机理特征建议。

package/presets/clearai/template/skills/data-analysis/templates/analysis_report.md.tpl

@@ -0,0 +1,63 @@
+# 数据深度分析报告 (Deep Data Analysis Report)
+
+**分析对象**: `{{ file_name }}`
+**分析时间**: `{{ analysis_time }}`
+**分析师**: ClearAI
+
+---
+
+## 1. 核心结论 (Executive Summary)
+> **一句话总结**: 数据质量评级为 **{{ quality_grade }}**，主要问题集中在 [XX] 方面，建议 [Action]。
+
+- **数据可用性**: [High/Medium/Low]
+- **关键发现**:
+  1. ...
+  2. ...
+
+---
+
+## 2. 四大维度视角分析 (Four-Lens Analysis)
+
+### 2.1 过程视角 (Process) - 稳定性与能力
+- **稳定性分析**: 关键参数 `{{ key_param }}` 的过程稳定性指标为 `{{ stability_value }}`（如 Cpk，目标: >1.33）。
+- **过程状态**: 是否处于受控/稳定状态？[Yes/No]
+- **过程异常**: 发现 `{{ anomaly_count }}` 次关键参数越限。
+
+### 2.2 质量视角 (Quality) - 缺陷与关联
+- **缺陷分布**: 主要缺陷类型为 `{{ top_defect }}`。
+- **关联分析**: `{{ key_param }}` 的波动与 `{{ defect_type }}` 呈现 [正/负] 相关。
+- **潜在风险**: ...
+
+### 2.3 代价视角 (Cost) - 损失量化
+- **质量损失估算**: 约 `{{ quality_loss_cost }}`（按项目约定的资源/成本单位）。
+- **优化潜力**: 若将过程稳定性提升至目标水平，预计节约 `{{ potential_saving }}`。
+
+### 2.4 连续性视角 (Continuity) - 覆盖与可用率
+- **有效时长**: 数据覆盖率为 `{{ coverage_rate }}%`。
+- **中断分析**: 识别出 `{{ downtime_count }}` 次异常中断/断数。
+
+---
+
+## 3. 详细画像 (Detailed Profiling)
+
+### 3.1 基础统计
+| 字段 | Min | Max | Mean | Std | Skew | Missing% |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| ... | ... | ... | ... | ... | ... | ... |
+
+### 3.2 物理/业务键分析
+- **Business Keys**: 识别出的主键为 `{{ primary_key }}`。
+- **实体关联**: 包含 `{{ entity_count }}` 个唯一实体（如批次、样本、会话）。
+
+---
+
+## 4. 建模建议 (Modeling Recommendations)
+1. **预处理建议**: ...
+2. **特征工程**: 建议构建特征见 `products/extracted/feature_candidates.json`。
+3. **模型选择**: 适合 [简单机理/复杂数据驱动] 建模。
+
+---
+
+## 5. 附录
+- [数据字典](products/extracted/data_dictionary.md)
+- [数据质量报告](products/extracted/data_quality_report.md)