CanonCode의 Rust 엔진 — .lex 파서부터 조항 충돌 감지까지

{
  "meta": {
    "project": "LaunchCrew",
    "version": "1.0.0",
    "language": "ko"
  },
  "constitution": [
    {
      "id": "CONST-001",
      "content": "모든 금전 거래는 에스크로를 통해야 한다",
      "rationale": "직접 송금 시 분쟁 해결 불가"
    }
  ],
  "acts": [
    {
      "id": "ACT-001",
      "title": "QA 공고 생성",
      "clauses": [
        {
          "id": "CL-001-1",
          "content": "공고 생성 시 결제 수단(point/card)을 선택한다",
          "references": ["CONST-001"]
        }
      ]
    }
  ],
  "case_law": [
    {
      "id": "CASE-001",
      "situation": "잔액 부족 상태에서 공고 생성 시도",
      "ruling": "422 에러 반환, 공고 생성 롤백",
      "references": ["CL-001-2", "CONST-001"]
    }
  ]
}

use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize)]
pub struct LexDocument {
    pub meta: Meta,
    pub constitution: Vec<Article>,
    pub acts: Vec<Act>,
    #[serde(default)]
    pub rules: Vec<Rule>,
    #[serde(default)]
    pub appendices: Vec<Appendix>,
    #[serde(default)]
    pub case_law: Vec<CaseLaw>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Article {
    pub id: String,
    pub content: String,
    #[serde(default)]
    pub rationale: Option<String>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Clause {
    pub id: String,
    pub content: String,
    #[serde(default)]
    pub references: Vec<String>,
    #[serde(default)]
    pub constraints: Vec<Constraint>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct CaseLaw {
    pub id: String,
    pub situation: String,
    pub ruling: String,
    pub references: Vec<String>,
}

pub fn parse_lex(content: &str) -> Result<LexDocument, LexError> {
    serde_json::from_str(content)
        .map_err(|e| LexError::ParseError(e.to_string()))
}

use std::collections::{HashMap, HashSet};

pub struct DependencyGraph {
    // 조항 ID → 조항 데이터
    nodes: HashMap<String, NodeData>,
    // 조항 ID → 참조하는 조항 ID 목록
    edges: HashMap<String, HashSet<String>>,
    // 역방향: 조항 ID → 이 조항을 참조하는 조항들
    reverse_edges: HashMap<String, HashSet<String>>,
}

impl DependencyGraph {
    pub fn build(doc: &LexDocument) -> Result<Self, LexError> {
        let mut graph = Self::new();

        // 1. 모든 조항을 노드로 등록
        for article in &doc.constitution {
            graph.add_node(&article.id, NodeLevel::Constitution);
        }
        for act in &doc.acts {
            for clause in &act.clauses {
                graph.add_node(&clause.id, NodeLevel::Clause);
            }
        }
        for case in &doc.case_law {
            graph.add_node(&case.id, NodeLevel::CaseLaw);
        }

        // 2. 참조 관계를 엣지로 등록
        for act in &doc.acts {
            for clause in &act.clauses {
                for ref_id in &clause.references {
                    graph.add_edge(&clause.id, ref_id)?;
                }
            }
        }
        for case in &doc.case_law {
            for ref_id in &case.references {
                graph.add_edge(&case.id, ref_id)?;
            }
        }

        // 3. 검증
        graph.validate()?;

        Ok(graph)
    }
}

fn validate(&self) -> Result<(), LexError> {
    // 1. 끊어진 참조: 존재하지 않는 ID를 참조
    for (from, refs) in &self.edges {
        for to in refs {
            if !self.nodes.contains_key(to) {
                return Err(LexError::BrokenReference(
                    from.clone(), to.clone()
                ));
            }
        }
    }

    // 2. 순환 참조: A → B → C → A
    self.detect_cycles()?;

    // 3. 계층 위반: 하위 법률이 상위를 건너뛰고 참조
    self.check_hierarchy()?;

    Ok(())
}

fn detect_cycles(&self) -> Result<(), LexError> {
    let mut visited = HashSet::new();
    let mut in_stack = HashSet::new();

    for node_id in self.nodes.keys() {
        if !visited.contains(node_id) {
            self.dfs_cycle(node_id, &mut visited, &mut in_stack)?;
        }
    }
    Ok(())
}

fn dfs_cycle(
    &self,
    node: &str,
    visited: &mut HashSet<String>,
    in_stack: &mut HashSet<String>,
) -> Result<(), LexError> {
    visited.insert(node.to_string());
    in_stack.insert(node.to_string());

    if let Some(refs) = self.edges.get(node) {
        for ref_id in refs {
            if !visited.contains(ref_id.as_str()) {
                self.dfs_cycle(ref_id, visited, in_stack)?;
            } else if in_stack.contains(ref_id.as_str()) {
                return Err(LexError::CircularReference(
                    node.to_string(), ref_id.clone()
                ));
            }
        }
    }

    in_stack.remove(node);
    Ok(())
}

pub struct ConflictRule {
    pub constitution_pattern: Vec<String>,  // 헌법 조항의 키워드
    pub clause_pattern: Vec<String>,        // 법률 조항의 키워드
    pub conflict_type: ConflictType,
    pub severity: Severity,
}

// 내장 규칙 예시
fn default_rules() -> Vec<ConflictRule> {
    vec![
        ConflictRule {
            constitution_pattern: vec!["balance".into(), ">= 0".into()],
            clause_pattern: vec!["deduct".into(), "subtract".into(), "차감".into()],
            conflict_type: ConflictType::PotentialViolation,
            severity: Severity::Warning,
        },
        ConflictRule {
            constitution_pattern: vec!["escrow".into(), "에스크로".into()],
            clause_pattern: vec!["direct".into(), "직접".into(), "송금".into()],
            conflict_type: ConflictType::DirectContradiction,
            severity: Severity::Error,
        },
    ]
}

use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "lex_cli")]
#[command(about = "CanonCode .lex file analyzer")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// .lex 파일 정보 출력
    Info {
        #[arg(short, long)]
        file: String,
    },
    /// 의존성 그래프 검증
    Validate {
        #[arg(short, long)]
        file: String,
    },
    /// 충돌 감지
    Check {
        #[arg(short, long)]
        file: String,
        #[arg(long, default_value = "warning")]
        severity: String,
    },
    /// 의존성 트리 시각화
    Tree {
        #[arg(short, long)]
        file: String,
        #[arg(long)]
        root: Option<String>,
    },
}

# 파일 정보
$ lex_cli info -f launchcrew.lex
Project: LaunchCrew v1.0.0
Constitution: 5 articles
Acts: 3 (12 clauses)
Rules: 4
Case Law: 6
References: 23 edges

# 검증
$ lex_cli validate -f launchcrew.lex
✅ No broken references
✅ No circular dependencies
✅ Hierarchy valid

# 충돌 감지
$ lex_cli check -f launchcrew.lex
⚠️  CL-003-2 ("수수료 차감") may conflict with CONST-001 ("잔액 >= 0")
    Type: PotentialViolation
    Suggestion: Add guard clause or update case_law

# 의존성 트리
$ lex_cli tree -f launchcrew.lex --root CONST-001
CONST-001: 모든 금전 거래는 에스크로를 통해야 한다
├── CL-001-2: point 타입 공고 시 즉시 에스크로
├── CL-003-1: 완료 시 에스크로 정산
├── CASE-001: 잔액 부족 → 422 롤백
└── CASE-002: 중도 포기 → 부분 반환