Transfer Old Latex To New

# transfer-old-latex-to-new 技能配置文件
# version: 2.1.0
# last_updated: 2026-03-28
#
# 说明：
# - 当前 skill 的主心智已收敛为“把旧材料内容迁移到现有模板项目的内容层”
# - 本文件仍主要服务 legacy CLI 与可选脚本入口
# - 核心安全边界：不得修改 packages/ 公共包源码，也不得修改 projects/ 内模板骨架或样式
# - 带有 NSFC 年份/章节假设的节点属于 legacy 增强模块，不代表整个 skill 只服务 NSFC

skill_info:
  name: transfer-old-latex-to-new
  version: 2.1.0
  description: "将旧项目、旧模板或多源材料中的正文内容迁移到当前 ChineseResearchLaTeX 现有模板项目的内容层；优先使用 transfer-old-latex-to-new 触发，也兼容旧别名 migrating-latex-templates；只允许写入正文与参考文献文件，绝不能修改 packages/ 公共包源码或 projects/ 模板样式骨架"
  author: "Bensz Conan"
  category: writing

orchestration:
  input_contract: "flexible"         # 任意合理输入皆可，由 AI 自主归并理解
  output_contract: "content_only"    # 交付物仅限内容层与必要说明，不做模板重构
  source_edit_policy: "read_only_by_default"  # 默认不原地改写用户源材料
  repo_awareness: "existing_project_content_slots" # 以现有项目的正文承载位点为准
  legacy_cli_mode: "optional"        # run.py / migrate.sh 仅作为可选硬编码后备

template_protection:
  forbid_package_source_edits: true
  forbid_project_template_edits: true
  on_template_gap: "report_instead_of_patch"
  allow_resource_writes: false
  allowed_write_patterns:
    - "^extraTex/(?!@config\\.tex$).+\\.tex$"
    - "^references/.+\\.bib$"

# =============================================================================
# 预设模板（简化配置使用）
# =============================================================================
profiles:
  quick:
    description: "快速模式（适合材料较少、结构较清晰的迁移或重构任务）"
    ai:
      batch_mode: false
      max_workers: 2
    cache:
      enabled: false
    content_optimization:
      max_rounds: 3

  balanced:
    description: "平衡模式（适合一般复杂度的多文件迁移或模板接入任务）"
    ai:
      batch_mode: true
      batch_size: 10
      max_workers: 4
    cache:
      enabled: true
    content_optimization:
      max_rounds: 5

  thorough:
    description: "精确模式（适合结构复杂、跨目录或跨产品线的重构任务）"
    ai:
      batch_mode: true
      batch_size: 20
      max_workers: 8
    cache:
      enabled: true
    content_optimization:
      max_rounds: 7

# =============================================================================
# legacy CLI 核心参数
# =============================================================================
migration:
  # 优化轮次控制
  max_rounds: 5                    # 最大优化轮次（AI根据项目复杂度自动调整）
  min_rounds: 3                    # 最小优化轮次
  convergence_threshold: 0.05      # 收敛阈值（连续两轮改进<5%则退出）

  # 备份策略
  backup_mode: "snapshot"          # 备份模式: snapshot(快照)/copy(复制)/none(跳过)
  backup_location: "runs"          # 备份位置: runs(默认，输出到本轮 .bensz-api run 目录的 input/backup/)/custom(自定义路径)
  keep_backup_days: 30             # 自动清理备份保留天数
  fine_grained_rollback: true      # 细粒度回滚（支持单文件恢复）

  # legacy CLI 的默认策略（主工作流仍以 AI 自主判断为准）
  default_strategy: "smart"        # smart(智能)/conservative(保守)/aggressive(激进)

  # 内容生成策略
  content_generation:
    method: "smart"                # smart(调用技能)/placeholder(占位符)/skip(跳过)
    placeholder_text: "\\textbf{[此部分内容需要补充]}"

  # 引用处理
  reference_handling: "preserve"   # preserve(保留原样)/update(更新编号)/recreate(重建)

  # 图片与附件处理
  figure_handling: "skip"           # copy(复制)/link(软链接)/skip(跳过)
  # 说明：
  # - copy: 将旧项目的资源文件复制到新项目（仅在明确放开内容资源写入时使用）
  # - link: 在新项目中创建指向旧项目资源的软链接（同样受模板保护策略约束）
  # - skip: 跳过资源文件处理，只迁移正文与参考文献（默认，推荐）

# =============================================================================
# 质量阈值配置
# =============================================================================
quality_thresholds:
  # 语义相似度（用于自动章节映射）
  min_similarity: 0.7              # 最小语义相似度（低于此值需人工确认）

  # 内容完整性
  min_word_count: 50               # 最小章节字数（低于此值发出警告）
  content_integrity: 0.95          # 内容完整性阈值（旧内容迁移比例）

  # 引用完整性
  max_ref_errors: 5                # 最大引用错误数（超过此值发出警告）
  max_undefined_refs: 3            # 最大未定义引用数

  # LaTeX编译
  max_compile_warnings: 10         # 最大编译警告数
  max_compile_errors: 0            # 最大编译错误数（必须为0）

  # 逻辑连贯性
  logical_coherence_threshold: 0.8 # 逻辑连贯性最低要求（AI评分）

# =============================================================================
# 编译参数配置
# =============================================================================
compilation:
  # LaTeX引擎
  engine: "xelatex"                # 编译引擎: xelatex/lualatex/pdflatex
  passes: 4                        # 标准编译轮数
  pass_sequence:                   # 编译序列
    - "xelatex"
    - "bibtex"
    - "xelatex"
    - "xelatex"

  # 编译选项
  interaction_mode: "nonstopmode"  # 交互模式: nonstopmode/batchmode/errorstopmode
  halt_on_error: false             # 遇到错误是否立即中止

  # 超时控制
  timeout_per_pass: 120            # 单次编译超时(秒)
  total_timeout: 600               # 总编译超时(秒)

# =============================================================================
# 缓存配置
# =============================================================================
cache:
  enabled: true                    # 启用缓存
  strategy: "layered"              # 分层策略: layered(三层)/simple(单层)/none(禁用)
  memory_max_size: 1000            # 内存缓存最大条目数
  disk_db_path: "cache/mapping_cache.db"  # 磁盘缓存路径（相对本轮 .bensz-api run 目录）
  ttl_days: 30                     # 缓存过期天数

# =============================================================================
# AI推理参数
# =============================================================================
ai:
  # 模型选择
  primary_model: "claude-opus-4-5" # 首选模型（用于复杂推理）
  fallback_model: "claude-sonnet-4-5"  # 降级模型（用于简单任务）
  embedding_model: "text-embedding-3-small"  # 嵌入模型（用于相似度计算）

  # 批量调用配置
  batch_mode: true                 # 启用批量模式
  batch_size: 10                   # 每批处理数量
  max_concurrent_batches: 3        # 最大并发批次数
  max_workers: 4                   # 最大并行 worker 数（默认 CPU 核心数）

  # 生成参数
  temperature: 0.3                 # 生成温度（低温度=更确定性的输出）
  max_tokens_per_request: 8000     # 单次请求最大token数
  top_p: 0.9                       # nucleus sampling参数
  top_k: 40                        # top-k sampling参数

  # 推理增强
  enable_cot: true                 # 启用Chain-of-Thought推理
  enable_self_reflection: true     # 启用自我反思机制
  max_reflection_rounds: 2         # 最大反思轮次

# =============================================================================
# 输出控制（legacy CLI 默认值；不代表 skill 的固定交付契约）
# =============================================================================
output:
  # 报告生成
  generate_report: true            # 生成迁移报告
  generate_change_summary: true    # 生成变更摘要
  generate_structure_comparison: true  # 生成结构对比

  # 日志控制
  verbose: true                    # 详细日志输出
  log_level: "INFO"                # 日志级别: DEBUG/INFO/WARNING/ERROR
  log_file: "migration.log"        # 日志文件名

  # 中间文件
  keep_intermediate: false         # 保留中间文件（用于调试）
  intermediate_dir: "intermediate"  # 中间文件目录（相对本轮 .bensz-api run 目录）

  # 交付物（仅供 legacy CLI 参考）
  deliverables_dir: "deliverables"  # 交付物目录（相对本轮 .bensz-api run 目录）
  deliverables:
    - "migrated_proposal.pdf"      # 迁移后的PDF
    - "migration_log.md"           # 迁移日志
    - "change_summary.md"          # 变更摘要
    - "structure_comparison.md"    # 结构对比
    - "restore_guide.md"           # 恢复指南

# =============================================================================
# 工作空间（本 skill 运行目录）
# =============================================================================
workspace:
  runs_dir: ".bensz-api/skills/transfer-old-latex-to-new"  # 运行产物根目录：./.bensz-api/skills/transfer-old-latex-to-new/<yyyy-mm-dd-hh-mm>/

# =============================================================================
# 智能决策规则（AI自主规划逻辑）
# =============================================================================
decision_rules:
  # 迭代轮次决策
  rounds_decision:
    simple:
      condition: "one_to_one_ratio >= 0.8"  # 简单一对一映射≥80%
      max_rounds: 3
    moderate:
      condition: "one_to_many_ratio + many_to_one_ratio >= 0.3"  # 复杂映射≥30%
      max_rounds: 5
    complex:
      condition: "new_added_count >= 3 OR structural_major_changes >= 2"
      max_rounds: 7

  # 迁移策略决策
  strategy_decision:
    conservative:
      condition: "high_risk_issues == 0"  # 无高风险问题
      description: "保守策略：优先保持现有模板骨架不变，只迁移内容"
    smart:
      condition: "one_to_many_ratio + many_to_one_ratio >= 0.2"  # 存在复杂映射
      description: "智能策略：AI只在正文内容层做拆分/合并映射"
    aggressive:
      condition: "new_added_count >= 5"  # 大量新增内容
      description: "激进策略：仅在单个正文文件内部做较大幅度内容整编，仍不触碰模板骨架"

  # 备份决策
  backup_decision:
    auto_snapshot:
      condition: "backup_mode == 'snapshot'"
      action: "create_git_stash"
    manual_backup:
      condition: "user_specified_backup_path"
      action: "copy_to_specified_location"

  # LaTeX编译失败处理
  compilation_failure_handling:
    missing_file:
      action: "abort_and_report"
      retry: false
    syntax_error:
      action: "attempt_auto_fix"
      retry: true
      max_retries: 3
    reference_error:
      action: "fix_references_and_continue"
      retry: true
    timeout:
      action: "report_and_continue"
      partial_result: true

# =============================================================================
# 结构映射配置（AI 驱动）
# =============================================================================
mapping:
  # AI 映射策略
  strategy: "ai_driven"             # ai_driven(AI语义判断)/fallback(简单启发式)

  # AI 判断阈值
  thresholds:
    high: 0.85                      # 高置信度阈值（AI 认为高度确定）
    medium: 0.7                     # 中置信度阈值（AI 认为比较确定）
    low: 0.5                        # 低置信度阈值（需人工确认）

  # 回退策略（当 AI 不可用时）
  fallback:
    enable_filename_exact_match: true   # 文件名完全匹配
    enable_filename_contains: true      # 文件名包含关系
    enable_jaccard_similarity: true     # Jaccard 相似度
    min_jaccard_threshold: 0.5          # 最小 Jaccard 相似度

  # 拆分策略（用于一对多映射）
  split_strategies:
    semantic_split:
      description: "按语义边界拆分（AI 判断）"
      priority: 1
    keyword_split:
      description: "按关键词出现位置拆分"
      priority: 2
    paragraph_split:
      description: "按段落边界拆分"
      priority: 3
    equal_split:
      description: "等分拆分"
      priority: 4  # 最后选择

  # 合并策略（用于多对一映射）
  merge_strategies:
    sequential_merge:
      description: "顺序拼接，添加过渡段"
      priority: 1
    semantic_reorder:
      description: "仅在目标正文文件内部按语义重新排序后合并"
      priority: 2
    smart_merge:
      description: "AI 在正文文件内部做智能整编"
      priority: 3

# =============================================================================
# 优化配置
# =============================================================================
optimization:
  # 每轮优化重点
  round_focus:
    - round: 1
      focus: ["logical_coherence", "transitions"]
      tools: ["manual_review", "nsfc-writing-core"]
    - round: 2
      focus: ["terminology_consistency", "reference_integrity"]
      tools: ["grep_terminology", "ref_validator"]
    - round: 3
      focus: ["content_depth", "evidence_quality"]
      tools: ["nsfc-rationale-writer", "nsfc-innovation-writer"]
    - round: 4
      focus: ["reference_integrity", "latex_compilation"]
      tools: ["latex_compiler", "linter"]
    - round: 5
      focus: ["readability", "final_polish"]
      tools: ["nsfc-writing-core", "human_review"]

  # 收敛判断条件（满足任一即提前退出）
  convergence_criteria:
    - condition: "total_quality_score >= 0.9"
      description: "总分≥90%"
    - condition: "consecutive_improvement < 0.05 for 2 rounds"
      description: "连续2轮改进<5%"
    - condition: "latex_compilation == 1.0 AND all_scores >= 0.8"
      description: "编译完美且无其他严重问题"
    - condition: "no_issues_found"
      description: "无发现任何问题"

# =============================================================================
# 风险评估
# =============================================================================
risk_assessment:
  # 高风险定义
  high_risk_indicators:
    - "目标内容必须修改 main.tex/@config/模板样式 才能落位"
    - "迁移诉求要求修改 packages/ 公共包源码"
    - "many_to_one合并导致核心论证断裂"
    - "删除核心正文内容"

  # 中风险定义
  medium_risk_indicators:
    - "合并章节需要添加过渡段"
    - "引用标签需要全局更新"
    - "当前模板内容位点与旧材料语义错位"
    - "图表资源缺失但不允许写入模板资源目录"

  # 低风险定义
  low_risk_indicators:
    - "简单一对一映射"
    - "正文润色"
    - "非核心章节迁移"

# =============================================================================
# 技能集成配置
# =============================================================================
skill_integration:
  # 可调用的 legacy NSFC 增强技能
  available_skills:
    nsfc-writing-core:
      purpose: "统一术语、检查一致性"
      trigger: "每次优化开始前"
      priority: 1

    nsfc-rationale-writer:
      purpose: "补强立项依据"
      trigger: "立项依据内容不足或质量低"
      priority: 2

    nsfc-aims-writer:
      purpose: "补强研究内容与目标"
      trigger: "研究内容章节需要优化"
      priority: 2

    nsfc-methods-feasibility-writer:
      purpose: "补强方案可行性、生成风险应对"
      trigger: "方案可行性章节需要优化或新增风险应对"
      priority: 2

    nsfc-innovation-writer:
      purpose: "提炼创新点"
      trigger: "特色与创新章节需要优化"
      priority: 3

    nsfc-foundation-conditions-writer:
      purpose: "补强研究基础与工作条件"
      trigger: "研究基础章节需要优化"
      priority: 3

    nsfc-workplan-writer:
      purpose: "补强研究计划"
      trigger: "研究计划章节需要优化"
      priority: 3

  # 技能调用策略
  call_strategy: "on_demand"        # on_demand(按需)/automatic(自动)/manual(手动)

# =============================================================================
# 调试选项
# =============================================================================
debug:
  enabled: false                     # 调试模式开关
  save_intermediate_json: true       # 保存所有中间JSON文件
  log_ai_decisions: true             # 记录AI决策过程
  verbose_error_messages: true       # 详细错误信息
  performance_profiling: true        # 性能分析

# =============================================================================
# 版本兼容性
# =============================================================================
compatibility:
  # legacy NSFC 增强模块支持的模板版本
  supported_versions:
    - "2025"
    - "2026"
    - "2024"

  # 版本映射表
  version_mapping:
    "2024_to_2025":
      structural_changes: ["章节编号体系变化", "部分章节合并"]
    "2025_to_2026":
      structural_changes: ["板块重组", "新增风险应对章节"]

  # 不兼容的版本对
  incompatible_pairs: []

  # 自动版本检测
  auto_detect: true                 # 自动检测项目版本
  warn_on_unsupported: true         # 遇到不支持版本时警告

# =============================================================================
# 插件系统
# =============================================================================
plugins:
  enabled: false                    # 插件系统开关（默认关闭）
  plugin_dir: "plugins"             # 插件目录
  auto_load: true                   # 自动加载插件

# =============================================================================
# 写作风格评分
# =============================================================================
style_scoring:
  enabled: true                     # 启用写作风格评分
  criteria:
    - "clarity"                     # 清晰度
    - "conciseness"                 # 简洁性
    - "coherence"                   # 连贯性
    - "academic_tone"               # 学术性
  threshold: 0.75                   # 最低质量阈值（低于此值会警告）

# =============================================================================
# 字数自动适配（legacy NSFC 增强模块）
# =============================================================================
word_count_adaptation:
  enabled: true                     # 启用字数自动适配
  auto_expand: true                 # 字数不足时自动扩展
  auto_compress: true               # 字数过多时自动精简
  target_tolerance: 50              # 目标容忍度（±50字）
  priority_strategy: "skill_first"  # 优先策略: skill_first(优先调用技能)/ai_direct(直接AI)

# =============================================================================
# 引用强制保护
# =============================================================================
reference_protection:
  enabled: true                     # 启用引用强制保护
  validation_mode: "strict"         # 验证模式: strict(严格)/lenient(宽松)
  auto_repair: true                 # 自动修复被破坏的引用
  log_violations: true              # 记录引用违规

# =============================================================================
# AI 内容智能优化
# =============================================================================
content_optimization:
  enabled: true                     # 启用 AI 内容优化
  auto_apply: true                  # 自动应用优化（无需人工确认）
  min_improvement_threshold: 0.1    # 最低改进阈值（低于此值不应用）
  optimization_types:
    - "redundancy"                  # 删除冗余
    - "logic"                       # 改进逻辑
    - "evidence"                    # 补充证据
    - "clarity"                     # 提高清晰度
  preserve_references: true         # 优化时保护引用
  max_optimization_passes: 3        # 每轮最大优化次数

# =============================================================================
# 元数据
# =============================================================================
metadata:
  skill_name: "transfer-old-latex-to-new"
  skill_version: "2.1.0"
  created_at: "2026-01-05"
  last_updated: "2026-03-28"
  author: "Bensz Conan"
  license: "MIT"

  # 依赖项
  dependencies:
    python: ">=3.8"
    latex: "texlive-full >= 2020"
    required_packages:
      - "ctex"
      - "xcolor"
      - "graphicx"
      - "float"
      - "hyperref"

  # 推荐配置
  recommended:
    os: ["Linux", "macOS", "Windows"]
    latex_editor: ["VSCode", "Overleaf", "TeXShop"]
    git_integration: true

"""transfer_old_latex_to_new core."""

# 新增工具模块（v1.3.0）
from .cache_manager import CacheManager
from .config_utils import (
    ConfigAccessor,
    ConfigDefaults,
    ThresholdDefaults,
    apply_profile,
    get_config_accessor,
)
from .json_utils import JsonParser, parse_json, parse_json_array, parse_batch_json
from .progress_utils import ProgressReporter, TaskGroup, iterate_with_progress, progress, task_group
from .prompt_templates import (
    MAPPING_JUDGE_TEMPLATE,
    OPTIMIZE_ANALYZE_TEMPLATE,
    OPTIMIZE_TYPE_PROMPTS,
    WORD_COUNT_COMPRESS_TEMPLATE,
    WORD_COUNT_EXPAND_TEMPLATE,
)

__all__ = [
    # 工具模块
    "CacheManager",
    "ConfigAccessor",
    "ConfigDefaults",
    "ThresholdDefaults",
    "JsonParser",
    "ProgressReporter",
    "TaskGroup",
    # 便捷函数
    "apply_profile",
    "get_config_accessor",
    "parse_json",
    "parse_json_array",
    "parse_batch_json",
    "iterate_with_progress",
    "progress",
    "task_group",
    # 提示词模板
    "MAPPING_JUDGE_TEMPLATE",
    "OPTIMIZE_ANALYZE_TEMPLATE",
    "OPTIMIZE_TYPE_PROMPTS",
    "WORD_COUNT_COMPRESS_TEMPLATE",
    "WORD_COUNT_EXPAND_TEMPLATE",
]

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from __future__ import annotations

import json
import logging
from typing import Any, Awaitable, Callable, Dict, List, Optional, Union


JsonDict = Dict[str, Any]
Responder = Callable[[str, str, str], Union[str, JsonDict, None, Awaitable[Union[str, JsonDict, None]]]]


class AIIntegration:
    """
    AI 集成层（优雅降级）

    说明：
    - 本仓库内的 Python 脚本默认不假设"可直接调用宿主 AI"。
    - 若未提供 responder（或 enable_ai=False），将自动回退到 fallback。
    - 该接口为后续真正的 AI 调用预留扩展点，同时保证当前功能可用。
    - 支持批量调用优化（v1.3.0）
    """

    def __init__(
        self,
        enable_ai: bool = True,
        config: Optional[Dict[str, Any]] = None,
        responder: Optional[Responder] = None,
    ) -> None:
        self.enable_ai = bool(enable_ai)
        self.config = config or {}
        self.responder = responder

        self.fallback_mode = False
        self.request_count = 0
        self.success_count = 0
        self.batch_count = 0  # 批量调用计数

        # 批量配置
        ai_cfg = (config.get("ai", {}) or {}) if isinstance(config, dict) else {}
        self.batch_mode = bool(ai_cfg.get("batch_mode", False))
        self.batch_size = int(ai_cfg.get("batch_size", 10))

    def is_available(self) -> bool:
        return bool(self.enable_ai and (not self.fallback_mode) and (self.responder is not None))

    def get_stats(self) -> Dict[str, Any]:
        return {
            "enabled": self.enable_ai,
            "fallback_mode": self.fallback_mode,
            "request_count": self.request_count,
            "success_count": self.success_count,
            "batch_count": self.batch_count,
            "success_rate": self.success_count / max(self.request_count, 1),
            "batch_mode_enabled": self.batch_mode,
        }

    async def process_request(
        self,
        *,
        task: str,
        prompt: str,
        fallback: Callable[[], Any],
        output_format: str = "json",
    ) -> Any:
        self.request_count += 1

        if not self.enable_ai:
            self.fallback_mode = True
            self._log_fallback(task, reason="AI disabled")
            return fallback()

        if self.responder is None:
            self.fallback_mode = True
            self._log_fallback(task, reason="No responder configured")
            return fallback()

        try:
            raw = self.responder(task, prompt, output_format)
            if hasattr(raw, "__await__"):
                raw = await raw  # type: ignore[misc]

            if raw is None:
                raise ValueError("Empty AI response")

            if output_format == "json":
                if isinstance(raw, dict):
                    self.success_count += 1
                    return raw
                parsed = self._parse_json_response(str(raw))
                if parsed is None:
                    raise ValueError("Failed to parse JSON response")
                self.success_count += 1
                return parsed

            if output_format == "text":
                self.success_count += 1
                return str(raw).strip()

            raise ValueError(f"Unsupported output_format: {output_format}")
        except Exception as e:
            self.fallback_mode = True
            self._log_fallback(task, reason=str(e))
            return fallback()

    @staticmethod
    def _parse_json_response(response_text: str) -> Optional[JsonDict]:
        # 1) fenced code block
        if "```json" in response_text:
            start = response_text.find("```json") + 7
            end = response_text.find("```", start)
            if end != -1:
                candidate = response_text[start:end].strip()
                try:
                    obj = json.loads(candidate)
                    return obj if isinstance(obj, dict) else None
                except Exception:
                    return None

        # 2) first balanced {...}
        start = response_text.find("{")
        if start == -1:
            return None

        depth = 0
        for i in range(start, len(response_text)):
            ch = response_text[i]
            if ch == "{":
                depth += 1
            elif ch == "}":
                depth -= 1
                if depth == 0:
                    candidate = response_text[start : i + 1]
                    try:
                        obj = json.loads(candidate)
                        return obj if isinstance(obj, dict) else None
                    except Exception:
                        return None

        return None

    @staticmethod
    def _log_fallback(task: str, reason: str) -> None:
        logger = logging.getLogger(__name__)
        if reason in {"AI disabled", "No responder configured"}:
            logger.info("[AIIntegration] fallback task=%s reason=%s", task, reason)
        else:
            logger.warning("[AIIntegration] fallback task=%s reason=%s", task, reason)

    async def process_batch_requests(
        self,
        *,
        task: str,
        prompts: List[str],
        fallback: Callable[[], List[Any]],
        output_format: str = "json",
    ) -> List[Any]:
        """
        批量处理 AI 请求（优化网络开销）

        Args:
            task: 任务名称
            prompts: 提示词列表
            fallback: 回退函数
            output_format: 输出格式

        Returns:
            结果列表
        """
        self.batch_count += 1
        self.request_count += len(prompts)

        if not self.enable_ai or self.responder is None:
            self.fallback_mode = True
            self._log_fallback(task, reason="AI disabled or No responder")
            return fallback()

        try:
            # 构建批量提示词
            batch_prompt = self._build_batch_prompt(prompts, output_format)

            # 调用 AI
            raw = self.responder(task, batch_prompt, output_format)
            if hasattr(raw, "__await__"):
                raw = await raw  # type: ignore[misc]

            if raw is None:
                raise ValueError("Empty AI response")

            # 解析批量结果
            if output_format == "json":
                results = self._parse_batch_json_response(raw)
                if len(results) != len(prompts):
                    raise ValueError("Batch JSON response length mismatch")
                self.success_count += len(results)
                return results
            elif output_format == "text":
                # 文本模式下，按行分割返回
                text = str(raw).strip()
                results = [line.strip() for line in text.split("\n") if line.strip()]
                self.success_count += len(results)
                return results
            else:
                raise ValueError(f"Unsupported output_format: {output_format}")

        except Exception as e:
            self.fallback_mode = True
            self._log_fallback(task, reason=str(e))
            return fallback()

    def _build_batch_prompt(self, prompts: List[str], output_format: str) -> str:
        """构建批量提示词"""
        batch_prompt = "请批量处理以下请求，返回 JSON 数组：\n\n"
        for i, prompt in enumerate(prompts, 1):
            batch_prompt += f"\n## 请求 {i}\n{prompt}\n"

        if output_format == "json":
            batch_prompt += "\n## 输出格式\n"
            batch_prompt += "请返回 JSON 数组，每个元素对应一个请求的结果：\n"
            batch_prompt += "```json\n[结果1, 结果2, ...]\n```\n"

        return batch_prompt

    def _parse_batch_json_response(self, response: Any) -> List[Any]:
        """解析批量 JSON 响应"""
        response_text = str(response)

        # 尝试提取 JSON 数组
        try:
            # 1) 提取 fenced code block 中的 JSON
            if "```json" in response_text:
                start = response_text.find("```json") + 7
                end = response_text.find("```", start)
                if end != -1:
                    json_str = response_text[start:end].strip()
                    data = json.loads(json_str)
                    if isinstance(data, list):
                        return data
            elif "```" in response_text:
                # 尝试无语言标记的代码块
                start = response_text.find("```") + 3
                end = response_text.find("```", start)
                if end != -1:
                    json_str = response_text[start:end].strip()
                    data = json.loads(json_str)
                    if isinstance(data, list):
                        return data

            # 2) 直接解析整个响应
            data = json.loads(response_text)
            if isinstance(data, list):
                return data

        except (json.JSONDecodeError, ValueError):
            pass

        # 3) 尝试提取多个 JSON 对象
        results = []
        for match in response_text.split("{"):
            if not match.strip():
                continue
            try:
                obj = json.loads("{" + match.split("}")[0] + "}")
                results.append(obj)
            except (json.JSONDecodeError, ValueError, IndexError):
                continue

        return results if len(results) > 1 else []

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
分层缓存管理器
- L1: 内存缓存（当前会话）
- L2: SQLite 磁盘缓存（跨会话）
"""

from __future__ import annotations

import hashlib
import json
import sqlite3
import time
from pathlib import Path
from typing import Any, Dict, Optional


class CacheManager:
    """分层缓存管理器"""

    # 缓存键最大长度（SQLite 限制）
    MAX_KEY_LENGTH = 256

    def __init__(self, cache_dir: str = "cache", db_name: str = "mapping_cache.db", ttl_days: int = 30):
        """
        初始化缓存管理器

        Args:
            cache_dir: 缓存目录（相对 runs/<run_id>/）
            db_name: 数据库文件名
            ttl_days: 缓存过期天数
        """
        self.cache_dir = Path(cache_dir)
        self.cache_dir.mkdir(parents=True, exist_ok=True)

        self.db_path = self.cache_dir / db_name
        self.ttl_seconds = ttl_days * 86400

        # L1: 内存缓存（当前会话）
        self.memory_cache: Dict[str, Any] = {}

        # L2: SQLite 磁盘缓存（跨会话）
        self.conn = sqlite3.connect(str(self.db_path), check_same_thread=False)
        self._init_db()

    def _init_db(self) -> None:
        """初始化数据库表"""
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS mapping_cache (
                cache_key TEXT PRIMARY KEY,
                result TEXT NOT NULL,
                timestamp REAL NOT NULL
            )
        """)
        self.conn.execute("""
            CREATE INDEX IF NOT EXISTS idx_timestamp ON mapping_cache(timestamp)
        """)
        self.conn.commit()

    def _make_key(self, old_file: str, new_file: str, context: Optional[Dict[str, Any]] = None) -> str:
        """
        生成缓存键

        使用 SHA256 哈希确保键的唯一性和固定长度
        """
        # 组合输入
        combined = f"{old_file}|{new_file}"
        if context:
            context_str = json.dumps(context, sort_keys=True)
            combined += f"|{context_str}"

        # SHA256 哈希
        hash_obj = hashlib.sha256(combined.encode('utf-8'))
        hash_hex = hash_obj.hexdigest()

        # 截取前 32 字符（足够唯一且不过长）
        return f"cache_{hash_hex[:32]}"

    def get(self, old_file: str, new_file: str, context: Optional[Dict[str, Any]] = None) -> Optional[Any]:
        """
        获取缓存（L1 → L2 → None）

        Args:
            old_file: 旧文件路径
            new_file: 新文件路径
            context: 可选上下文信息

        Returns:
            缓存结果，如果不存在则返回 None
        """
        cache_key = self._make_key(old_file, new_file, context)

        # L1: 内存缓存
        if cache_key in self.memory_cache:
            return self.memory_cache[cache_key]

        # L2: SQLite 缓存
        cursor = self.conn.execute(
            "SELECT result, timestamp FROM mapping_cache WHERE cache_key = ?",
            (cache_key,)
        )
        row = cursor.fetchone()

        if row:
            result_json, timestamp = row

            # 检查是否过期
            if time.time() - timestamp < self.ttl_seconds:
                try:
                    result = json.loads(result_json)
                    # 提升到 L1
                    self.memory_cache[cache_key] = result
                    return result
                except (json.JSONDecodeError, ValueError):
                    # 缓存损坏，删除
                    self.conn.execute("DELETE FROM mapping_cache WHERE cache_key = ?", (cache_key,))
                    self.conn.commit()

        return None

    def set(self, old_file: str, new_file: str, result: Any, context: Optional[Dict[str, Any]] = None) -> None:
        """
        设置缓存（同时写入 L1 和 L2）

        Args:
            old_file: 旧文件路径
            new_file: 新文件路径
            result: 要缓存的结果
            context: 可选上下文信息
        """
        cache_key = self._make_key(old_file, new_file, context)
        current_time = time.time()

        # 写入 L1
        self.memory_cache[cache_key] = result

        # 写入 L2
        try:
            result_json = json.dumps(result, ensure_ascii=False)
            self.conn.execute(
                "INSERT OR REPLACE INTO mapping_cache (cache_key, result, timestamp) VALUES (?, ?, ?)",
                (cache_key, result_json, current_time)
            )
            self.conn.commit()
        except (json.JSONDecodeError, ValueError, TypeError):
            # 结果无法序列化，只缓存到 L1（内存）
            pass

    def clear_expired(self) -> int:
        """
        清理过期缓存

        Returns:
            清理的条目数
        """
        current_time = time.time()
        cursor = self.conn.execute(
            "DELETE FROM mapping_cache WHERE ? - timestamp > ?",
            (current_time, self.ttl_seconds)
        )
        self.conn.commit()
        return cursor.rowcount

    def clear_all(self) -> int:
        """
        清理所有缓存

        Returns:
            清理的条目数
        """
        cursor = self.conn.execute("SELECT COUNT(*) FROM mapping_cache")
        count = cursor.fetchone()[0]

        self.conn.execute("DELETE FROM mapping_cache")
        self.conn.commit()

        # 清空 L1
        self.memory_cache.clear()

        return count

    def get_stats(self) -> Dict[str, Any]:
        """
        获取缓存统计信息

        Returns:
            统计信息字典
        """
        # L1 统计
        l1_count = len(self.memory_cache)

        # L2 统计
        cursor = self.conn.execute("SELECT COUNT(*) FROM mapping_cache")
        l2_count = cursor.fetchone()[0]

        cursor = self.conn.execute("SELECT COUNT(*) FROM mapping_cache WHERE ? - timestamp > ?",
                                   (time.time(), self.ttl_seconds))
        expired_count = cursor.fetchone()[0]

        return {
            "l1_count": l1_count,
            "l2_count": l2_count,
            "expired_count": expired_count,
            "ttl_days": self.ttl_seconds / 86400,
        }

    def close(self) -> None:
        """关闭数据库连接"""
        if self.conn:
            self.conn.close()

    def __del__(self) -> None:
        """析构函数，确保连接关闭"""
        try:
            self.close()
        except Exception:
            pass

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from __future__ import annotations

import re
import subprocess
import os
import time
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple


ERROR_RE = re.compile(r"^! ", re.MULTILINE)
UNDEF_REF_RE = re.compile(r"LaTeX Warning: Reference `[^']+' on page")
UNDEF_CITE_RE = re.compile(r"LaTeX Warning: Citation `[^']+' on page")


@dataclass(frozen=True)
class CompileStep:
    command: List[str]
    returncode: int
    stdout_path: str
    stderr_path: str


@dataclass(frozen=True)
class CompileSummary:
    success: bool
    steps: List[CompileStep]
    error_count: int
    undefined_ref_count: int
    undefined_cite_count: int

    def to_dict(self) -> Dict[str, Any]:
        return {
            "success": self.success,
            "error_count": self.error_count,
            "undefined_ref_count": self.undefined_ref_count,
            "undefined_cite_count": self.undefined_cite_count,
            "steps": [asdict(s) for s in self.steps],
        }


def _run(cmd: List[str], cwd: Path, stdout_path: Path, stderr_path: Path, timeout_s: int) -> int:
    p = subprocess.run(
        cmd,
        cwd=str(cwd),
        stdout=stdout_path.open("w", encoding="utf-8"),
        stderr=stderr_path.open("w", encoding="utf-8"),
        timeout=timeout_s,
        check=False,
        env=os.environ.copy(),
        text=True,
    )
    return int(p.returncode)


def compile_project(new_project: Path, logs_dir: Path, config: Dict[str, Any]) -> CompileSummary:
    new_project = new_project.resolve()
    logs_dir = logs_dir.resolve()
    logs_dir.mkdir(parents=True, exist_ok=True)

    # 创建 LaTeX 中间文件目录(与日志分离)
    latex_aux_dir = logs_dir / "latex_aux"
    latex_aux_dir.mkdir(parents=True, exist_ok=True)

    compilation = config.get("compilation", {}) or {}
    engine = str(compilation.get("engine", "xelatex"))
    interaction = str(compilation.get("interaction_mode", "nonstopmode"))
    pass_sequence = compilation.get("pass_sequence") or ["xelatex", "bibtex", "xelatex", "xelatex"]
    halt_on_error = bool(compilation.get("halt_on_error", False))
    timeout_per_pass = int(compilation.get("timeout_per_pass", 120))
    total_timeout = int(compilation.get("total_timeout", 0) or 0)
    passes = compilation.get("passes")
    if passes is not None:
        try:
            pass_count = int(passes)
            if pass_count > 0:
                pass_sequence = list(pass_sequence)[:pass_count]
        except Exception:
            pass

    steps: List[CompileStep] = []
    start_time = time.time()

    for idx, step in enumerate(pass_sequence, start=1):
        remaining_total = None
        if total_timeout > 0:
            elapsed = time.time() - start_time
            remaining_total = total_timeout - int(elapsed)
            if remaining_total <= 0:
                stdout_path = logs_dir / f"compile_{idx}_{step}.out.txt"
                stderr_path = logs_dir / f"compile_{idx}_{step}.err.txt"
                stdout_path.write_text("", encoding="utf-8")
                stderr_path.write_text("total_timeout\n", encoding="utf-8")
                steps.append(
                    CompileStep(
                        command=[step],
                        returncode=124,
                        stdout_path=str(stdout_path),
                        stderr_path=str(stderr_path),
                    )
                )
                break

        timeout = min(timeout_per_pass, remaining_total) if remaining_total else timeout_per_pass

        if step in {"bibtex", "biber"}:
            # bibtex/biber 需要在 latex_aux_dir 中运行(因为 .aux/.bcf 文件在那里)
            cmd = [step, "main"]
            run_cwd = latex_aux_dir
        else:
            # xelatex 使用 -output-directory 参数将中间文件写到隔离目录
            cmd = [
                step,
                f"-interaction={interaction}",
                f"-output-directory={latex_aux_dir}",
                "main.tex",
            ]
            run_cwd = new_project

        stdout_path = logs_dir / f"compile_{idx}_{step}.out.txt"
        stderr_path = logs_dir / f"compile_{idx}_{step}.err.txt"

        try:
            # bibtex 在 latex_aux_dir 运行时，.aux 内的 bst/bib 路径通常是相对 new_project 的；
            # 通过 BSTINPUTS/BIBINPUTS 将 new_project 加入搜索路径，避免 “I couldn't open style/database file”。
            if step in {"bibtex", "biber"}:
                env = os.environ.copy()
                for key in ("BSTINPUTS", "BIBINPUTS"):
                    existing = env.get(key, "")
                    prefix = str(new_project) + os.pathsep
                    env[key] = prefix + existing
                rc = subprocess.run(
                    cmd,
                    cwd=str(run_cwd),
                    stdout=stdout_path.open("w", encoding="utf-8"),
                    stderr=stderr_path.open("w", encoding="utf-8"),
                    timeout=timeout,
                    check=False,
                    text=True,
                    env=env,
                ).returncode
                rc = int(rc)
            else:
                rc = _run(cmd, cwd=run_cwd, stdout_path=stdout_path, stderr_path=stderr_path, timeout_s=timeout)
        except FileNotFoundError:
            # 缺少 xelatex/bibtex 等环境时，输出可读错误
            stdout_path.write_text("", encoding="utf-8")
            stderr_path.write_text(f"command not found: {cmd[0]}\n", encoding="utf-8")
            rc = 127
        except subprocess.TimeoutExpired:
            stdout_path.write_text("", encoding="utf-8")
            stderr_path.write_text("timeout\n", encoding="utf-8")
            rc = 124

        steps.append(
            CompileStep(
                command=cmd,
                returncode=rc,
                stdout_path=str(stdout_path),
                stderr_path=str(stderr_path),
            )
        )

        if rc != 0 and halt_on_error:
            # 用户选择遇到错误立即中止
            break

    # 简易汇总：读取 main.log（若存在）统计未定义引用等
    # 注意：main.log 现在在 latex_aux_dir 中，但 main.pdf 仍在 new_project 中
    log_path = latex_aux_dir / "main.log"
    log_text = log_path.read_text(encoding="utf-8", errors="replace") if log_path.exists() else ""
    error_count = len(ERROR_RE.findall(log_text))
    undef_ref = len(UNDEF_REF_RE.findall(log_text))
    undef_cite = len(UNDEF_CITE_RE.findall(log_text))

    # 将生成的 PDF 复制到项目根目录（方便用户查看）
    pdf_source = latex_aux_dir / "main.pdf"
    pdf_target = new_project / "main.pdf"
    if pdf_source.exists():
        import shutil
        shutil.copy2(pdf_source, pdf_target)

    success = steps and all(s.returncode == 0 for s in steps) and error_count == 0

    return CompileSummary(
        success=bool(success),
        steps=steps,
        error_count=error_count,
        undefined_ref_count=undef_ref,
        undefined_cite_count=undef_cite,
    )

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
from typing import Any, Dict, List, Optional


DEFAULT_CONFIG: Dict[str, Any] = {
    "template_protection": {
        "forbid_package_source_edits": True,
        "forbid_project_template_edits": True,
        "on_template_gap": "report_instead_of_patch",
        "allow_resource_writes": False,
        "allowed_write_patterns": [
            r"^extraTex/(?!@config\.tex$).+\.tex$",
            r"^references/.+\.bib$",
        ],
    },
    "migration": {
        "max_rounds": 5,
        "min_rounds": 3,
        "convergence_threshold": 0.05,
        "default_strategy": "smart",
        "content_generation": {
            "method": "placeholder",
            "placeholder_text": "\\textbf{[此部分内容需要补充]}",
        },
        "figure_handling": "skip",
    },
    "quality_thresholds": {
        "min_similarity": 0.7,
        "min_word_count": 50,
    },
    "compilation": {
        "engine": "xelatex",
        "pass_sequence": ["xelatex", "bibtex", "xelatex", "xelatex"],
        "interaction_mode": "nonstopmode",
        "timeout_per_pass": 120,
        "total_timeout": 600,
    },
    "mapping_heuristics": {
        "title_similarity_weight": 0.4,
        "content_similarity_weight": 0.3,
        "position_proximity_weight": 0.2,
        "structural_pattern_weight": 0.1,
        "high_similarity_threshold": 0.85,
        "medium_similarity_threshold": 0.7,
        "low_similarity_threshold": 0.5,
    },
    "output": {
        "verbose": True,
    },
    "workspace": {
        "runs_dir": ".bensz-api/skills/transfer-old-latex-to-new",
    },
    # 预设配置（profiles）
    "profiles": {
        "quick": {
            "description": "快速模式（适合小项目，<20 个文件）",
            "ai": {
                "batch_mode": False,
                "max_workers": 2,
            },
            "cache": {
                "enabled": False,
            },
            "content_optimization": {
                "max_rounds": 3,
            },
        },
        "balanced": {
            "description": "平衡模式（适合中型项目，20-100 个文件）",
            "ai": {
                "batch_mode": True,
                "batch_size": 10,
                "max_workers": 4,
            },
            "cache": {
                "enabled": True,
                "memory_max_size": 1000,
            },
            "content_optimization": {
                "max_rounds": 5,
            },
        },
        "thorough": {
            "description": "精确模式（适合大型项目，>100 个文件）",
            "ai": {
                "batch_mode": True,
                "batch_size": 20,
                "max_workers": 8,
            },
            "cache": {
                "enabled": True,
                "memory_max_size": 2000,
            },
            "content_optimization": {
                "max_rounds": 7,
            },
        },
    },
}


def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
    merged: Dict[str, Any] = dict(base)
    for key, value in (override or {}).items():
        if isinstance(value, dict) and isinstance(merged.get(key), dict):
            merged[key] = _deep_merge(merged[key], value)
        else:
            merged[key] = value
    return merged


def load_config(skill_root: Path) -> Dict[str, Any]:
    config_path = Path(skill_root) / "config.yaml"
    config: Dict[str, Any] = dict(DEFAULT_CONFIG)
    if not config_path.exists():
        return config

    try:
        import yaml  # type: ignore
    except Exception:
        return config

    try:
        raw = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
        if not isinstance(raw, dict):
            return config
        return _deep_merge(config, raw)
    except Exception:
        return config


@dataclass(frozen=True)
class MappingThresholds:
    high: float
    medium: float
    low: float


def get_mapping_thresholds(config: Dict[str, Any]) -> MappingThresholds:
    mapping = config.get("mapping", {}) or {}
    thresholds = (mapping.get("thresholds") or {}) if isinstance(mapping, dict) else {}
    if isinstance(thresholds, dict) and thresholds:
        return MappingThresholds(
            high=float(thresholds.get("high", 0.85)),
            medium=float(thresholds.get("medium", 0.7)),
            low=float(thresholds.get("low", 0.5)),
        )

    mh = config.get("mapping_heuristics", {}) or {}
    return MappingThresholds(
        high=float(mh.get("high_similarity_threshold", 0.85)),
        medium=float(mh.get("medium_similarity_threshold", 0.7)),
        low=float(mh.get("low_similarity_threshold", 0.5)),
    )


def get_runs_dir(skill_root: Path, config: Dict[str, Any]) -> Path:
    runs_dir = (config.get("workspace", {}) or {}).get("runs_dir", "runs")
    path = Path(str(runs_dir)).expanduser()
    if path.is_absolute():
        return path.resolve()
    if str(runs_dir) == "runs":
        return (Path(skill_root) / path).resolve()
    return (Path.cwd() / path).resolve()


def apply_profile(config: Dict[str, Any], profile_name: Optional[str] = None) -> Dict[str, Any]:
    """
    应用配置预设（profile）

    Args:
        config: 原始配置
        profile_name: 预设名称（quick/balanced/thorough），None 表示不应用

    Returns:
        应用预设后的配置
    """
    if not profile_name:
        return config

    profiles = config.get("profiles", {})
    profile = profiles.get(profile_name, {})

    if not profile:
        return config

    return _deep_merge(config, profile)


def list_profiles(config: Optional[Dict[str, Any]] = None) -> List[str]:
    """
    列出可用的配置预设

    Args:
        config: 配置字典（None 则使用默认配置）

    Returns:
        预设名称列表
    """
    if config is None:
        config = DEFAULT_CONFIG

    profiles = config.get("profiles", {})
    return list(profiles.keys())


def get_profile_description(config: Dict[str, Any], profile_name: str) -> Optional[str]:
    """
    获取预设的描述

    Args:
        config: 配置字典
        profile_name: 预设名称

    Returns:
        预设描述，不存在返回 None
    """
    profiles = config.get("profiles", {})
    profile = profiles.get(profile_name, {})
    return profile.get("description") if isinstance(profile, dict) else None


def load_config_with_profile(
    skill_root: Path,
    profile: Optional[str] = None,
) -> Dict[str, Any]:
    """
    加载配置并应用预设

    Args:
        skill_root: 技能根目录
        profile: 预设名称（可选）

    Returns:
        最终配置
    """
    config = load_config(skill_root)
    return apply_profile(config, profile)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
配置工具模块
- 统一类型检查
- 简化配置访问
- 支持默认值
"""

from __future__ import annotations

from typing import Any, Callable, Dict, List, Optional, TypeVar, Union

from .config_loader import _deep_merge

T = TypeVar("T")


class ConfigAccessor:
    """
    配置访问器

    提供类型安全的配置访问方法，避免重复的 isinstance 检查
    """

    def __init__(self, config: Optional[Dict[str, Any]] = None):
        """
        初始化配置访问器

        Args:
            config: 配置字典（None 则返回默认值）
        """
        self._config = config if isinstance(config, dict) else {}

    def get(self, key: str, default: T = None, expected_type: Optional[type] = None) -> Union[T, Any]:
        """
        获取配置值

        Args:
            key: 配置键（支持点号分隔的嵌套键，如 "ai.batch_mode"）
            default: 默认值
            expected_type: 期望的类型（None 表示不检查）

        Returns:
            配置值或默认值
        """
        # 支持嵌套键（如 "ai.batch_mode"）
        keys = key.split(".")
        value = self._config

        for k in keys:
            if isinstance(value, dict):
                value = value.get(k)
                if value is None:
                    return default
            else:
                return default

        # 检查类型
        if value is None:
            return default
        if expected_type is not None and not isinstance(value, expected_type):
            try:
                # 尝试类型转换
                return expected_type(value)
            except (ValueError, TypeError):
                return default

        return value

    def get_bool(self, key: str, default: bool = False) -> bool:
        """获取布尔值"""
        return bool(self.get(key, default, bool))

    def get_int(self, key: str, default: int = 0) -> int:
        """获取整数值"""
        return int(self.get(key, default, int))

    def get_float(self, key: str, default: float = 0.0) -> float:
        """获取浮点数值"""
        return float(self.get(key, default, (int, float)))

    def get_str(self, key: str, default: str = "") -> str:
        """获取字符串值"""
        return str(self.get(key, default, str))

    def get_list(self, key: str, default: Optional[List[Any]] = None) -> List[Any]:
        """获取列表值"""
        if default is None:
            default = []
        value = self.get(key, default)
        if isinstance(value, list):
            return value
        if isinstance(value, tuple):
            return list(value)
        return default

    def get_dict(self, key: str, default: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """获取字典值"""
        if default is None:
            default = {}
        value = self.get(key, default)
        if isinstance(value, dict):
            return value
        return default

    def sub(self, key: str) -> "ConfigAccessor":
        """
        获取子配置的访问器

        Args:
            key: 子配置键

        Returns:
            新的 ConfigAccessor 实例
        """
        return ConfigAccessor(self.get_dict(key))

    def has(self, key: str) -> bool:
        """
        检查配置键是否存在

        Args:
            key: 配置键

        Returns:
            是否存在
        """
        keys = key.split(".")
        value = self._config

        for k in keys:
            if isinstance(value, dict):
                if k not in value:
                    return False
                value = value[k]
            else:
                return False

        return True

    @property
    def raw(self) -> Dict[str, Any]:
        """获取原始配置字典"""
        return self._config.copy()


def apply_profile(config: Dict[str, Any], profile_name: str) -> Dict[str, Any]:
    """
    应用配置预设（profile）

    Args:
        config: 原始配置
        profile_name: 预设名称（quick/balanced/thorough）

    Returns:
        应用预设后的配置
    """
    profiles = config.get("profiles", {})
    profile = profiles.get(profile_name, {})

    if not profile:
        return config

    return _deep_merge(config, profile)


def get_config_accessor(config: Optional[Dict[str, Any]] = None, profile: Optional[str] = None) -> ConfigAccessor:
    """
    获取配置访问器

    Args:
        config: 配置字典
        profile: 可选的预设名称

    Returns:
        ConfigAccessor 实例
    """
    if profile and config:
        config = apply_profile(config, profile)

    return ConfigAccessor(config)


# 常量定义（消除魔法数字）
class ConfigDefaults:
    """配置默认值常量"""

    # AI 调用
    AI_BATCH_SIZE = 10
    AI_MAX_WORKERS = 4
    AI_TEMPERATURE = 0.3

    # 缓存
    CACHE_TTL_DAYS = 30
    CACHE_MEMORY_MAX_SIZE = 1000

    # 引用验证
    REFERENCE_INTACT_RATE_MIN = 0.95

    # 内容优化
    CONTENT_MIN_IMPROVEMENT = 0.1
    CONTENT_MIN_WORD_COUNT = 500

    # 编译
    COMPILE_TIMEOUT_PER_PASS = 120
    COMPILE_TOTAL_TIMEOUT = 600

    # 字数适配
    WORD_COUNT_TOLERANCE = 50
    WORD_COUNT_DEFAULT_TARGET = 3000

    # LaTeX 命令检测（内容长度限制）
    LATEX_CONTENT_PREVIEW_LENGTH = 500
    LATEX_AI_PROMPT_LENGTH = 1500
    LATEX_AI_MAX_LENGTH = 2000


class ThresholdDefaults:
    """阈值默认值"""

    # 映射置信度阈值
    MAPPING_HIGH = 0.85
    MAPPING_MEDIUM = 0.7
    MAPPING_LOW = 0.5

    # 质量阈值
    MIN_SIMILARITY = 0.7
    MIN_WORD_COUNT = 50
    CONTENT_INTEGRITY = 0.95
    LOGICAL_COHERENCE = 0.8

    # 编译阈值
    MAX_COMPILE_WARNINGS = 10
    MAX_COMPILE_ERRORS = 0
    MAX_REF_ERRORS = 5
    MAX_UNDEFINED_REFS = 3

"""
AI 内容智能优化器
自动识别并优化内容质量问题
"""

import json
import re
from typing import Dict, List, Optional
from pathlib import Path

from .ai_integration import AIIntegration
from .config_utils import ConfigDefaults
from .prompt_templates import OPTIMIZE_ANALYZE_TEMPLATE, OPTIMIZE_TYPE_PROMPTS
from .reference_guardian import ReferenceGuardian


class ContentOptimizer:
    """AI 内容智能优化器"""

    def __init__(self, config: dict, skill_root: str):
        self.config = config
        self.skill_root = Path(skill_root)
        self.ref_guardian = ReferenceGuardian(config)

    async def optimize_content(
        self,
        content: str,
        section_title: str,
        optimization_goals: dict,
        ai_integration: Optional[AIIntegration] = None,
    ) -> dict:
        """智能优化内容"""
        if ai_integration is None:
            ai_integration = AIIntegration(enable_ai=True, config=self.config)

        # 第一步：保护引用
        protected_content, ref_map = self.ref_guardian.protect_references(content)
        original_refs = self.ref_guardian._extract_all_references(content)

        # 第二步：AI 分析优化点
        analysis = await self._analyze_optimization_points(
            protected_content, section_title, optimization_goals, ai_integration
        )

        # 第三步：执行优化
        optimized_content = protected_content
        optimization_log = []

        for point in analysis.get("optimization_points", []):
            result = await self._apply_optimization(optimized_content, point, ai_integration)
            if result.get("success"):
                optimized_content = result["content"]
                optimization_log.append({
                    "type": point["type"],
                    "description": point["description"],
                    "action": result["action"]
                })

        # 第四步：恢复引用
        final_content = self.ref_guardian.restore_references(optimized_content, ref_map)

        # 第五步：验证引用完整性
        validation = self.ref_guardian.validate_references(final_content, original_refs)

        return {
            "original_content": content,
            "optimized_content": final_content,
            "optimization_log": optimization_log,
            "reference_validation": validation,
            "improvement_score": analysis.get("improvement_potential", 0)
        }

    async def _analyze_optimization_points(
        self,
        content: str,
        section_title: str,
        goals: dict,
        ai_integration: AIIntegration,
    ) -> dict:
        """AI 分析优化点（使用当前 AI 环境）"""
        # 构建分析提示
        goal_desc = []
        if goals.get("remove_redundancy"):
            goal_desc.append("冗余表述")
        if goals.get("improve_logic"):
            goal_desc.append("逻辑连贯性")
        if goals.get("add_evidence"):
            goal_desc.append("证据支持")
        if goals.get("improve_clarity"):
            goal_desc.append("表述清晰度")
        if goals.get("reorganize_structure"):
            goal_desc.append("段落结构")

        goals_str = "、".join(goal_desc) if goal_desc else "整体质量"

        # 使用提示词模板
        prompt = OPTIMIZE_ANALYZE_TEMPLATE.format(
            section_title=section_title,
            goals_str=goals_str,
            content=content[:ConfigDefaults.LATEX_AI_PROMPT_LENGTH],
        )

        def fallback() -> dict:
            return self._heuristic_analysis(content, goals)

        result = await ai_integration.process_request(
            task="analyze_optimization_points",
            prompt=prompt,
            fallback=fallback,
            output_format="json",
        )

        return result if isinstance(result, dict) else fallback()

    def _heuristic_analysis(self, content: str, goals: dict) -> dict:
        """启发式分析（AI 失败时的回退方案）"""
        optimization_points = []

        if goals.get("remove_redundancy"):
            # 检测重复词（粗略启发式）
            # 1) 统计较短的中文片段出现次数（更能捕捉“测试测试测试...”这类重复）
            chunks = re.findall(r"[\u4e00-\u9fff]+", content)
            bigrams: Dict[str, int] = {}
            for chunk in chunks:
                if len(chunk) < 2:
                    continue
                for i in range(0, len(chunk) - 1):
                    bg = chunk[i : i + 2]
                    bigrams[bg] = bigrams.get(bg, 0) + 1

            if bigrams:
                bg, count = max(bigrams.items(), key=lambda x: x[1])
                if count >= 15:
                    optimization_points.append(
                        {
                            "type": "redundancy",
                            "description": f"短语'{bg}'重复{count}次（疑似冗余）",
                            "location": "全文",
                            "severity": "medium",
                            "suggestion": "替换同义词或重组表述",
                        }
                    )

            # 2) 统计连续中文“词块”重复（适合有分隔符的场景）
            if not optimization_points:
                words = re.findall(r"[\u4e00-\u9fff]{2,}", content)
                word_counts: Dict[str, int] = {}
                for word in words:
                    word_counts[word] = word_counts.get(word, 0) + 1

                for word, count in word_counts.items():
                    if count > 8:
                        optimization_points.append(
                            {
                                "type": "redundancy",
                                "description": f"词语'{word}'重复{count}次",
                                "location": "全文",
                                "severity": "medium",
                                "suggestion": "替换同义词或重组表述",
                            }
                        )
                        break

        if goals.get("improve_logic"):
            # 检测段落连接
            paragraphs = content.split('\n\n')
            if len(paragraphs) > 1 and not any('因此' in p or '总之' in p for p in paragraphs):
                optimization_points.append({
                    "type": "logic",
                    "description": "段落间缺乏过渡",
                    "location": "全文",
                    "severity": "medium",
                    "suggestion": "添加过渡句"
                })

        if goals.get("add_evidence") and len(content) < 500:
            optimization_points.append({
                "type": "evidence",
                "description": "内容可能缺乏充分论证",
                "location": "全文",
                "severity": "high",
                "suggestion": "补充数据或案例支持"
            })

        return {
            "optimization_points": optimization_points,
            "improvement_potential": min(0.7, len(optimization_points) * 0.2)
        }

    async def _apply_optimization(self, content: str, optimization_point: dict, ai_integration: AIIntegration) -> dict:
        """应用单个优化点（使用当前 AI 环境）"""
        opt_type = optimization_point["type"]
        description = optimization_point["description"]

        # 从模板中获取提示词
        prompt_template = OPTIMIZE_TYPE_PROMPTS.get(opt_type)
        if not prompt_template:
            return {"success": False, "reason": f"未知优化类型: {opt_type}"}

        prompt = prompt_template.format(description=description)
        prompt = prompt.replace("{content}", content[:ConfigDefaults.LATEX_AI_MAX_LENGTH])

        def fallback() -> str:
            return ""

        response = await ai_integration.process_request(
            task=f"apply_optimization_{opt_type}",
            prompt=prompt,
            fallback=fallback,
            output_format="text",
        )

        response_text = str(response or "").strip()
        if response_text:
            return {"success": True, "content": response_text, "action": f"优化{opt_type}"}
        return {"success": False, "reason": "AI 不可用或未返回内容"}

    def generate_optimization_report(self, content: str, section_title: str) -> dict:
        """生成优化报告（不执行优化，仅分析）"""
        # 简单的启发式分析
        issues = []

        # 检测可能的问题
        if content.count("\n\n") < 2:
            issues.append({
                "type": "structure",
                "severity": "low",
                "description": "段落结构可能过于简单"
            })

        if len(content) < 500:
            issues.append({
                "type": "evidence",
                "severity": "medium",
                "description": "内容可能过于简略"
            })

        # 检测重复词
        words = re.findall(r'[\u4e00-\u9fff]{2,}', content)
        word_counts = {}
        for word in words:
            word_counts[word] = word_counts.get(word, 0) + 1

        for word, count in word_counts.items():
            if count > 10:
                issues.append({
                    "type": "redundancy",
                    "severity": "low",
                    "description": f"词语'{word}'重复{count}次，可能存在冗余"
                })

        return {
            "section": section_title,
            "total_issues": len(issues),
            "issues": issues,
            "improvement_potential": min(0.8, len(issues) * 0.15)
        }