derive.js

import { nowIso, sha256, stableStringify } from "./utils.js";

const KEYWORD_TAGS = [
  "followup",
  "complaint",
  "payment",
  "order",
  "support",
  "agent",
  "customer",
  "preference",
  "approval",
  "跟进",
  "回访",
  "月供",
  "预算",
  "试驾",
  "置换",
  "七座",
  "金融方案",
  "销售"
];

export function buildDerivedMemories(session, entityIds, schemaVersion) {
  const timestamp = nowIso();
  const summary = buildSummary(session);
  const tags = buildTags(session);
  const facts = buildFacts(session);

  const derived = [];

  for (const entityId of entityIds) {
    derived.push({
      derived_id: `drv_${sha256(`${session.session_id}:${entityId}:summary`).slice(0, 18)}`,
      session_id: session.session_id,
      entity_id: entityId,
      derived_type: "summary",
      content: {
        text: summary,
        layer: "derived"
      },
      version: 1,
      model_info: {
        provider: "heuristic",
        name: "summary-v1"
      },
      confidence: 0.72,
      created_at: timestamp,
      schema_version: schemaVersion
    });

    for (const tag of tags) {
      derived.push({
        derived_id: `drv_${sha256(`${session.session_id}:${entityId}:tag:${tag}`).slice(0, 18)}`,
        session_id: session.session_id,
        entity_id: entityId,
        derived_type: "tag",
        content: {
          tag,
          layer: "derived"
        },
        version: 1,
        model_info: {
          provider: "heuristic",
          name: "tag-v1"
        },
        confidence: 0.7,
        created_at: timestamp,
        schema_version: schemaVersion
      });
    }

    for (const fact of facts) {
      derived.push({
        derived_id: `drv_${sha256(`${session.session_id}:${entityId}:fact:${stableStringify(fact)}`).slice(0, 18)}`,
        session_id: session.session_id,
        entity_id: entityId,
        derived_type: "fact",
        content: {
          ...fact,
          layer: "derived"
        },
        version: 1,
        model_info: {
          provider: "heuristic",
          name: "fact-v1"
        },
        confidence: 0.62,
        created_at: timestamp,
        schema_version: schemaVersion
      });
    }
  }

  return derived;
}

export function normalizeRawContent(rawContent) {
  if (typeof rawContent === "string") {
    return rawContent.trim();
  }

  return stableStringify(rawContent);
}

export function buildLongTermDerivedRecords({
  sessionId,
  entityIds,
  memories,
  schemaVersion,
  provider = "heuristic",
  model = "memory-extractor-v1"
}) {
  const timestamp = nowIso();
  const records = [];

  for (const entityId of entityIds) {
    for (const memory of memories) {
      records.push({
        derived_id: `drv_${sha256(`${sessionId}:${entityId}:long:${stableStringify(memory)}`).slice(0, 18)}`,
        session_id: sessionId,
        entity_id: entityId,
        derived_type: "long_term_memory",
        content: {
          title: memory.title,
          memory: memory.content,
          category: memory.category,
          importance: memory.importance,
          layer: "long_term"
        },
        version: 1,
        model_info: {
          provider,
          name: model
        },
        confidence: memory.confidence ?? 0.7,
        created_at: timestamp,
        schema_version: schemaVersion
      });
    }
  }

  return records;
}

function buildSummary(session) {
  const normalized = normalizeRawContent(session.raw_content);
  const compact = normalized.replace(/\s+/g, " ").trim();
  if (compact.length <= 220) {
    return compact;
  }

  return `${compact.slice(0, 217)}...`;
}

function buildTags(session) {
  const text = normalizeRawContent(session.raw_content).toLowerCase();
  const normalizedText = text.replace(/[^a-z0-9\u4e00-\u9fa5]+/g, " ");
  const compactText = text.replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "");
  const tags = new Set([
    session.session_type,
    session.source_system,
    session.raw_format,
    session.language
  ].filter(Boolean));

  for (const keyword of KEYWORD_TAGS) {
    if (text.includes(keyword.toLowerCase()) || normalizedText.includes(keyword.toLowerCase()) || compactText.includes(keyword.toLowerCase())) {
      tags.add(keyword);
    }
  }

  if (session.importance_hint) {
    tags.add(`importance:${session.importance_hint}`);
  }

  return [...tags];
}

function buildFacts(session) {
  const facts = [];
  const raw = session.raw_content;

  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
    for (const key of ["preference", "preferences", "fact", "facts", "预算", "偏好", "跟进", "风险"]) {
      if (raw[key]) {
        facts.push({
          key: mapFactKey(key),
          value: raw[key]
        });
      }
    }
  }

  const text = normalizeRawContent(raw);
  collectRegexFacts(text, facts);
  return dedupeFacts(facts);
}

function collectRegexFacts(text, facts) {
  const patterns = [
    { key: "preference", regex: /(?:prefers?|likes?)\s+([^.。]+?)(?:[.。]|$)/i },
    { key: "follow_up", regex: /follow[- ]?up\s+(?:on\s+)?([^.。]+?)(?:[.。]|$)/i },
    { key: "preference", regex: /(?:偏好|更喜欢|喜欢|想要|更在意)([^。；\n]+)/ },
    { key: "budget", regex: /(?:预算|月供|总价)([^。；\n]+)/ },
    { key: "follow_up", regex: /(?:跟进|回访|联系)([^。；\n]+)/ },
    { key: "constraint", regex: /(?:担心|顾虑|卡点)([^。；\n]+)/ }
  ];

  for (const pattern of patterns) {
    const match = text.match(pattern.regex);
    if (match?.[1]?.trim()) {
      facts.push({
        key: pattern.key,
        value: match[1].trim()
      });
    }
  }
}

function mapFactKey(key) {
  const mapping = {
    偏好: "preference",
    预算: "budget",
    跟进: "follow_up",
    风险: "risk"
  };
  return mapping[key] || key;
}

function dedupeFacts(facts) {
  const seen = new Set();
  return facts.filter((fact) => {
    const key = stableStringify(fact);
    if (seen.has(key)) {
      return false;
    }
    seen.add(key);
    return true;
  });
}