社外に出せない機密文書をどうAI検索するか？
社内閉域データとPostgreSQL pgvectorによる安全なナレッジ検索（RAG）

#![forbid(unsafe_code)]

/// Document chunk metadata retrieved from db01 PostgreSQL 19 knowledge store.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct KnowledgeChunkCandidate {
    pub chunk_id: u64,
    pub tenant_id: u64,
    pub required_clearance_mask: u64,
    pub is_latest_revision: bool,
    pub bm25_rank: Option<u32>,  // 1-indexed rank from lexical search
    pub dense_rank: Option<u32>, // 1-indexed rank from pgvector HNSW search
    pub cosine_similarity_permille: u16,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ScoredChunkResult {
    pub chunk_id: u64,
    /// Fixed-point RRF score scaled by 1_000_000 for deterministic integer sorting.
    pub rrf_score_micros: u64,
    pub cosine_similarity_permille: u16,
}

pub const RRF_K_CONSTANT: u64 = 60;
pub const MIN_GROUNDED_SIMILARITY_PERMILLE: u16 = 780;

/// Enforces tenant isolation, role clearance bitmask, revision freshness, and computes
/// deterministic Reciprocal Rank Fusion (RRF) scores without floating-point non-determinism.
pub fn rank_and_filter_authorized_chunks(
    request_tenant_id: u64,
    user_clearance_mask: u64,
    candidates: &[KnowledgeChunkCandidate],
    top_k: usize,
) -> Vec<ScoredChunkResult> {
    let mut authorized_scored: Vec<ScoredChunkResult> = Vec::new();

    for c in candidates {
        // Hard security invariant: tenant match, active revision, and RBAC bitmask authorization
        if c.tenant_id != request_tenant_id
            || !c.is_latest_revision
            || (c.required_clearance_mask & user_clearance_mask) != c.required_clearance_mask
        {
            continue;
        }

        if c.cosine_similarity_permille < MIN_GROUNDED_SIMILARITY_PERMILLE && c.bm25_rank.is_none() {
            continue;
        }

        let mut score_micros: u64 = 0;
        if let Some(r_bm25) = c.bm25_rank {
            score_micros += 1_000_000 / (RRF_K_CONSTANT + (r_bm25 as u64));
        }
        if let Some(r_dense) = c.dense_rank {
            score_micros += 1_000_000 / (RRF_K_CONSTANT + (r_dense as u64));
        }

        if score_micros > 0 {
            authorized_scored.push(ScoredChunkResult {
                chunk_id: c.chunk_id,
                rrf_score_micros: score_micros,
                cosine_similarity_permille: c.cosine_similarity_permille,
            });
        }
    }

    // Sort descending by RRF score, then by cosine similarity, then ascending by chunk_id
    authorized_scored.sort_by(|a, b| {
        b.rrf_score_micros
            .cmp(&a.rrf_score_micros)
            .then_with(|| b.cosine_similarity_permille.cmp(&a.cosine_similarity_permille))
            .then_with(|| a.chunk_id.cmp(&b.chunk_id))
    });

    authorized_scored.truncate(top_k);
    authorized_scored
}

/// Redacts long contiguous digit sequences (8..=16 digits, e.g., phone/account/ID numbers)
/// prior to vector embedding to prevent PII leakage into embedding space.
pub fn redact_digit_pii_sequences(input: &str) -> String {
    let mut out = String::with_capacity(input.len());
    let mut digit_run = String::new();

    for ch in input.chars() {
        if ch.is_ascii_digit() || ch == '-' {
            digit_run.push(ch);
        } else {
            let raw_digits = digit_run.chars().filter(|c| c.is_ascii_digit()).count();
            if (8..=16).contains(&raw_digits) {
                out.push_str("[PII_REDACTED]");
            } else {
                out.push_str(&digit_run);
            }
            digit_run.clear();
            out.push(ch);
        }
    }
    let trailing_digits = digit_run.chars().filter(|c| c.is_ascii_digit()).count();
    if (8..=16).contains(&trailing_digits) {
        out.push_str("[PII_REDACTED]");
    } else {
        out.push_str(&digit_run);
    }
    out
}