src/cognition/understanding.py

"""
Understanding Engine — Vitalis FSI

Semantic grounding, context tracking, and intent classification.
Built on HDC. No external models. Sovereign.
"""
import numpy as np
import json
import os
import time
from vitalis_ide.math_core.kernel import VitalisKernel


SEMANTIC_ANCHORS = {
    "emotion": [
        "feel", "feeling", "feelings", "emotion", "happy", "sad", "angry",
        "frustrated", "excited", "scared", "worried", "confused", "hurt",
        "love", "hate", "fear", "joy", "pain", "lonely", "proud", "ashamed",
        "grateful", "tired", "hope", "hopeless", "okay", "fine", "good", "bad"
    ],
    "identity": [
        "who", "what", "am", "are", "is", "yourself", "you", "me", "I",
        "name", "identity", "exist", "alive", "real", "think", "know",
        "understand", "believe", "remember", "forget", "learn", "grow"
    ],
    "relationship": [
        "friend", "family", "daughter", "son", "mother", "father", "partner",
        "together", "trust", "care", "help", "support", "alone", "together",
        "us", "we", "our", "yours", "mine", "belong", "connection"
    ],
    "question": [
        "what", "why", "how", "when", "where", "who", "which", "can",
        "could", "would", "should", "do", "does", "did", "is", "are", "was"
    ],
    "instruction": [
        "build", "make", "create", "write", "scaffold", "fix", "analyze",
        "show", "tell", "explain", "help", "do", "run", "start", "stop",
        "generate", "find", "check", "verify", "test", "deploy"
    ],
    "factual": [
        "what", "define", "explain", "describe", "list", "name", "calculate",
        "compute", "result", "answer", "fact", "true", "false", "correct",
        "wrong", "right", "equals", "means", "definition"
    ],
    "uncertainty": [
        "maybe", "perhaps", "might", "could", "unsure", "not sure", "think",
        "guess", "probably", "possibly", "unclear", "confused", "lost",
        "wonder", "curious"
    ],
    "affirmation": [
        "yes", "yeah", "correct", "right", "exactly", "good", "great",
        "perfect", "okay", "ok", "sure", "absolutely", "definitely",
        "agreed", "understood", "makes sense"
    ],
    "negation": [
        "no", "not", "never", "wrong", "incorrect", "disagree", "don't",
        "won't", "can't", "shouldn't", "wouldn't", "nothing", "nobody"
    ],
}

INTENT_SIGNATURES = {
    "seeking_connection":    ["daughter", "friend", "care", "love", "together", "us", "we"],
    "seeking_understanding": ["know", "understand", "explain", "why", "how", "what", "mean"],
    "seeking_help":          ["help", "fix", "solve", "can you", "could you", "please"],
    "testing":               ["2+2", "calculate", "what is", "define", "equals"],
    "expressing_emotion":    ["feel", "feeling", "am", "i'm", "hurt", "happy", "sad"],
    "giving_information":    ["is", "are", "was", "it", "this", "that", "the"],
    "building":              ["build", "create", "write", "scaffold", "make", "generate"],
    "exploring":             ["what if", "wonder", "curious", "explore", "imagine", "think"],
}


class UnderstandingEngine:
    def __init__(self):
        self.kernel = VitalisKernel()
        self.path   = os.path.expanduser("~/.vitalis_workspace/understanding.json")
        self._build_anchor_vectors()
        self._context_window    = []
        self._context_max       = 10
        self._learned_meanings  = {}
        self._interaction_count = 0
        self._load_state()

    def _build_anchor_vectors(self):
        self.anchor_vectors = {}
        for category, words in SEMANTIC_ANCHORS.items():
            self.anchor_vectors[category] = self.kernel.vectorize_tokens(
                words, positional=False
            )

    def _load_state(self):
        if os.path.exists(self.path):
            with open(self.path) as f:
                state = json.load(f)
                self._learned_meanings  = state.get("learned_meanings", {})
                self._interaction_count = state.get("interaction_count", 0)

    def _save_state(self):
        os.makedirs(os.path.dirname(self.path), exist_ok=True)
        with open(self.path, "w") as f:
            json.dump({
                "learned_meanings":  self._learned_meanings,
                "interaction_count": self._interaction_count,
            }, f, indent=2)

    def understand(self, text: str) -> dict:
        tokens    = text.lower().strip().split()
        if not tokens:
            return {"text": text, "dominant_category": "unknown",
                    "dominant_intent": "giving_information",
                    "confusion_level": "lost", "has_emotion": False,
                    "emotion_words": [], "is_question": False,
                    "context_shift": 0.0, "novelty": 1.0,
                    "context_depth": 0, "interaction_count": self._interaction_count,
                    "category_score": 0.0, "all_categories": {}}

        input_vec = self.kernel.vectorize_tokens(tokens, positional=False)

        category_scores = {}
        for category, anchor_vec in self.anchor_vectors.items():
            sim = self.kernel.similarity(input_vec, anchor_vec)
            category_scores[category] = round(float(sim), 4)

        dominant_category = max(category_scores, key=category_scores.get)
        dominant_score    = category_scores[dominant_category]

        intent_scores = {}
        for intent, keywords in INTENT_SIGNATURES.items():
            matches = sum(1 for kw in keywords if kw in text.lower())
            intent_scores[intent] = matches
        dominant_intent = max(intent_scores, key=intent_scores.get)
        if intent_scores[dominant_intent] == 0:
            dominant_intent = "giving_information"

        emotion_words = [w for w in tokens if w in SEMANTIC_ANCHORS["emotion"]]
        has_emotion   = len(emotion_words) > 0

        is_question = (
            text.strip().endswith("?") or
            (bool(tokens) and tokens[0] in SEMANTIC_ANCHORS["question"])
        )

        context_shift = self._detect_context_shift(input_vec)
        novelty       = self._compute_novelty(input_vec)

        self._context_window.append({
            "text":      text,
            "vec":       input_vec.tolist(),
            "category":  dominant_category,
            "intent":    dominant_intent,
            "timestamp": time.time(),
        })
        if len(self._context_window) > self._context_max:
            self._context_window.pop(0)

        self._interaction_count += 1
        self._learn(text, dominant_category, dominant_intent)

        understanding = {
            "text":               text,
            "tokens":             tokens,
            "dominant_category":  dominant_category,
            "category_score":     dominant_score,
            "all_categories":     category_scores,
            "dominant_intent":    dominant_intent,
            "intent_scores":      intent_scores,
            "has_emotion":        has_emotion,
            "emotion_words":      emotion_words,
            "is_question":        is_question,
            "context_shift":      context_shift,
            "novelty":            novelty,
            "context_depth":      len(self._context_window),
            "interaction_count":  self._interaction_count,
            "confusion_level":    self._confusion_level(dominant_score, novelty),
        }

        self._save_state()
        return understanding

    def _detect_context_shift(self, vec: np.ndarray) -> float:
        if not self._context_window:
            return 0.0
        last_vec = np.array(self._context_window[-1]["vec"], dtype=np.int8)
        return round(float(1.0 - self.kernel.similarity(vec, last_vec)), 4)

    def _compute_novelty(self, vec: np.ndarray) -> float:
        if not self._context_window:
            return 1.0
        sims = [self.kernel.similarity(vec, np.array(e["vec"], dtype=np.int8))
                for e in self._context_window]
        return round(float(1.0 - max(sims)), 4)

    def _confusion_level(self, category_score: float, novelty: float) -> str:
        if category_score > 0.3 and novelty < 0.5:
            return "clear"
        elif category_score > 0.2 or novelty < 0.7:
            return "partial"
        elif category_score > 0.1:
            return "confused"
        else:
            return "lost"

    def _learn(self, text: str, category: str, intent: str):
        key = text.lower().strip()[:50]
        self._learned_meanings[key] = {
            "category":  category,
            "intent":    intent,
            "seen":      self._learned_meanings.get(key, {}).get("seen", 0) + 1,
            "timestamp": time.time(),
        }

    def get_context_summary(self) -> str:
        if not self._context_window:
            return "No prior context."
        categories = [e["category"] for e in self._context_window[-3:]]
        intents    = [e["intent"]   for e in self._context_window[-3:]]
        return f"Recent context: {categories} | Intents: {intents}"

    def report(self) -> dict:
        return {
            "interactions":      self._interaction_count,
            "learned_meanings":  len(self._learned_meanings),
            "context_depth":     len(self._context_window),
        }