# 容错JSON解析器 (Tolerant JSON Parser)

基于Tree-sitter的大模型JSON容错解析器，专为处理大模型返回的不规范JSON数据而设计。

## 功能特性

### 🚀 核心功能
- **容错解析**: 处理各种JSON格式错误，包括语法错误、格式不一致等
- **YAML智能解析**: 自动识别并解析JSON字符串字段中的YAML内容
- **多种恢复策略**: 标准JSON解析、手动修复、正则提取、部分解析
- **Markdown支持**: 自动提取Markdown代码块中的JSON内容
- **性能优化**: 内置缓存机制，支持高频解析场景
- **详细统计**: 提供解析统计信息，包括错误率、恢复策略使用情况

### 🛠️ 支持的错误类型
- **无引号键**: `{name: "value"}` → `{"name": "value"}`
- **尾随逗号**: `{"key": "value",}` → `{"key": "value"}`
- **单引号**: `{'key': 'value'}` → `{"key": "value"}`
- **Markdown包裹**: 自动提取 ```json 代码块中的内容
- **混合内容**: 从包含解释性文本的内容中提取JSON
- **部分截断**: 处理不完整的JSON数据

### 🎯 YAML智能解析
- **自动检测**: 智能识别JSON字符串字段中的YAML格式内容
- **键值对解析**: `"config: name: John\nage: 30"` → `{"name": "John", "age": 30}`
- **列表解析**: `"items: - item1\n- item2"` → `["item1", "item2"]`
- **嵌套结构**: 支持复杂的YAML嵌套对象和数组
- **混合格式**: 处理大模型返回的JSON+YAML混合内容

## 快速开始

### Rust后端使用

```rust
use crate::infrastructure::tolerant_json_parser::{TolerantJsonParser, ParserConfig};

// 创建解析器实例
let mut parser = TolerantJsonParser::new(None)?;

// 解析JSON文本
let json_text = r#"
这是一个JSON示例：
```json
{name: "test", value: 123,}
```
"#;

let (parsed_value, stats) = parser.parse(json_text)?;
println!("解析结果: {:?}", parsed_value);
println!("错误率: {:.2}%", stats.error_rate * 100.0);
println!("使用的恢复策略: {:?}", stats.recovery_strategies_used);
```

### YAML智能解析示例

```rust
// 处理包含YAML内容的JSON
let json_with_yaml = r#"
{
  "retrievedContext": {
    "text": "categories:\n  - 修身\n  - 抹胸\n  - 高腰\ndescription: 三位女性模特展示夏季时尚穿搭\nenvironment_tags:\n  - 城市街道\n  - 夏季\n  - 晴朗"
  }
}
"#;

let (result, stats) = parser.parse(json_with_yaml)?;

// text字段会被自动解析为YAML对象
if let Some(text_obj) = result["retrievedContext"]["text"].as_object() {
    println!("categories: {:?}", text_obj["categories"]);
    println!("description: {:?}", text_obj["description"]);
    println!("environment_tags: {:?}", text_obj["environment_tags"]);
}

// 检查是否使用了YAML解析
if stats.recovery_strategies_used.contains(&"YamlStringParsing".to_string()) {
    println!("✅ 检测到并解析了YAML内容");
}
```

### 带缓存的解析器

```rust
use crate::infrastructure::tolerant_json_parser::CachedTolerantJsonParser;

// 创建带缓存的解析器
let cached_parser = CachedTolerantJsonParser::new(None, Some(1000))?;

// 解析JSON（自动缓存）
let (result, stats) = cached_parser.parse(json_text)?;

// 获取缓存统计
let (cache_size, max_size) = cached_parser.get_cache_stats();
println!("缓存使用: {}/{}", cache_size, max_size);
```

### 自定义配置

```rust
use crate::infrastructure::tolerant_json_parser::{ParserConfig, RecoveryStrategy};

let config = ParserConfig {
    max_text_length: 1024 * 1024, // 1MB
    enable_comments: true,
    enable_unquoted_keys: true,
    enable_trailing_commas: true,
    timeout_ms: 30000,
    recovery_strategies: vec![
        RecoveryStrategy::StandardJson,
        RecoveryStrategy::ManualFix,
        RecoveryStrategy::RegexExtract,
    ],
};

let mut parser = TolerantJsonParser::new(Some(config))?;
```

## Tauri命令接口

### 前端调用示例

```typescript
import { invoke } from '@tauri-apps/api/core';

// 解析JSON文本
async function parseJsonTolerant(text: string) {
  try {
    const response = await invoke('parse_json_tolerant', {
      request: {
        text: text,
        config: {
          max_text_length: 1024 * 1024,
          enable_comments: true,
          enable_unquoted_keys: true,
          enable_trailing_commas: true,
          timeout_ms: 30000,
          recovery_strategies: ['StandardJson', 'ManualFix', 'RegexExtract']
        }
      }
    });
    
    if (response.success) {
      console.log('解析成功:', response.data);
      console.log('统计信息:', response.statistics);
      return response.data;
    } else {
      console.error('解析失败:', response.error);
      return null;
    }
  } catch (error) {
    console.error('调用失败:', error);
    return null;
  }
}

// 验证JSON格式
async function validateJson(text: string): Promise<boolean> {
  return await invoke('validate_json_format', { text });
}

// 格式化JSON
async function formatJson(text: string, indent: number = 2): Promise<string> {
  return await invoke('format_json_text', { text, indent });
}

// 获取支持的恢复策略
async function getRecoveryStrategies(): Promise<string[]> {
  return await invoke('get_recovery_strategies');
}

// 获取默认配置
async function getDefaultConfig() {
  return await invoke('get_default_parser_config');
}
```

### React组件示例

```tsx
import React, { useState } from 'react';

interface JsonParserProps {
  onResult?: (result: any) => void;
}

export const JsonParser: React.FC<JsonParserProps> = ({ onResult }) => {
  const [input, setInput] = useState('');
  const [result, setResult] = useState<any>(null);
  const [error, setError] = useState<string | null>(null);
  const [loading, setLoading] = useState(false);

  const handleParse = async () => {
    if (!input.trim()) return;
    
    setLoading(true);
    setError(null);
    
    try {
      const response = await invoke('parse_json_tolerant', {
        request: { text: input }
      });
      
      if (response.success) {
        setResult(response.data);
        onResult?.(response.data);
      } else {
        setError(response.error);
      }
    } catch (err) {
      setError(err instanceof Error ? err.message : '解析失败');
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="json-parser">
      <div className="input-section">
        <textarea
          value={input}
          onChange={(e) => setInput(e.target.value)}
          placeholder="输入JSON文本..."
          className="w-full h-32 p-2 border rounded"
        />
        <button
          onClick={handleParse}
          disabled={loading || !input.trim()}
          className="mt-2 px-4 py-2 bg-blue-500 text-white rounded disabled:opacity-50"
        >
          {loading ? '解析中...' : '解析JSON'}
        </button>
      </div>
      
      {error && (
        <div className="error mt-4 p-2 bg-red-100 border border-red-400 rounded">
          错误: {error}
        </div>
      )}
      
      {result && (
        <div className="result mt-4">
          <h3 className="font-bold">解析结果:</h3>
          <pre className="bg-gray-100 p-2 rounded overflow-auto">
            {JSON.stringify(result, null, 2)}
          </pre>
        </div>
      )}
    </div>
  );
};
```

## API参考

### TolerantJsonParser

#### 构造函数
```rust
pub fn new(config: Option<ParserConfig>) -> Result<Self>
```

#### 方法
- `parse(text: &str) -> Result<(Value, ParseStatistics)>`: 解析JSON文本

### CachedTolerantJsonParser

#### 构造函数
```rust
pub fn new(config: Option<ParserConfig>, max_cache_size: Option<usize>) -> Result<Self>
```

#### 方法
- `parse(text: &str) -> Result<(Value, ParseStatistics)>`: 带缓存的解析
- `clear_cache()`: 清空缓存
- `get_cache_stats() -> (usize, usize)`: 获取缓存统计

### Tauri命令

- `parse_json_tolerant(request: ParseJsonRequest) -> ParseJsonResponse`
- `validate_json_format(text: String) -> bool`
- `format_json_text(text: String, indent: Option<usize>) -> String`
- `get_recovery_strategies() -> Vec<String>`
- `get_default_parser_config() -> JsonParserConfig`

## 配置选项

### ParserConfig

```rust
pub struct ParserConfig {
    pub max_text_length: usize,      // 最大文本长度
    pub enable_comments: bool,        // 启用注释支持
    pub enable_unquoted_keys: bool,   // 启用无引号键
    pub enable_trailing_commas: bool, // 启用尾随逗号
    pub timeout_ms: u64,             // 超时时间
    pub recovery_strategies: Vec<RecoveryStrategy>, // 恢复策略
}
```

### RecoveryStrategy

- `StandardJson`: 标准JSON解析
- `ManualFix`: 手动修复常见错误
- `RegexExtract`: 正则表达式提取
- `PartialParse`: 部分解析

## 性能特性

- **缓存机制**: 自动缓存解析结果，提高重复解析性能
- **增量解析**: 基于Tree-sitter的增量解析能力
- **内存优化**: 智能内存管理，避免内存泄漏
- **并发安全**: 支持多线程环境下的安全使用

## 测试

运行单元测试：
```bash
cargo test tolerant_json_parser --lib
```

运行特定测试：
```bash
cargo test test_standard_json_parsing --lib
cargo test test_markdown_wrapped_json --lib
cargo test test_cached_parser --lib
```

## 许可证

本项目遵循项目根目录的许可证条款。
