@simbimbo/memory-ocmemog 0.1.11 → 0.1.12

package/brain/runtime/memory/person_identity.py

@@ -1,83 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Tuple
-import re
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-from brain.runtime.memory import person_memory
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def extract_intro_candidate(text: str) -> str | None:
-    if not isinstance(text, str):
-        return None
-    cleaned = text.strip()
-    if not cleaned:
-        return None
-    lowered = cleaned.lower().strip(".!")
-    call_me_match = re.search(r"\byou can call me\s+([a-z][a-z\-']*)", lowered)
-    if call_me_match:
-        return call_me_match.group(1).strip(" .!").title()
-    direct_call_match = re.search(r"\bcall me\s+([a-z][a-z\-']*)", lowered)
-    if direct_call_match:
-        return direct_call_match.group(1).strip(" .!").title()
-    patterns = [
-        r"^my name is (.+)$",
-        r"^i am (.+)$",
-        r"^i'm (.+)$",
-    ]
-    for pattern in patterns:
-        match = re.match(pattern, lowered)
-        if match:
-            candidate = match.group(1).split(" but ")[0].strip(" .!")
-            return candidate.title() if candidate else None
-    return None
-
-
-def extract_name_candidate(text: str) -> str | None:
-    candidate = extract_intro_candidate(text)
-    if candidate:
-        return candidate
-    if not isinstance(text, str):
-        return None
-    cleaned = text.strip()
-    if not cleaned:
-        return None
-    tokens = [token for token in cleaned.replace(".", "").split() if token]
-    if 1 <= len(tokens) <= 3:
-        return " ".join(tokens)
-    return None
-
-
-def extract_operator_name(text: str) -> str | None:
-    from brain.runtime import inference
-
-    llm_result = inference.parse_operator_name(text)
-    llm_name = llm_result.get("name") if isinstance(llm_result, dict) else ""
-    if isinstance(llm_name, str) and llm_name.strip():
-        return llm_name.strip()
-    return extract_name_candidate(text)
-
-
-def resolve_interaction_person(metadata: Dict[str, str]) -> Tuple[Dict[str, object] | None, float, bool]:
-    person = None
-    confidence = 0.0
-    name_input = metadata.get("name") or ""
-    name_candidate = extract_name_candidate(name_input) if name_input else None
-    if name_candidate:
-        person = person_memory.get_person(name_candidate) or person_memory.create_person(name_candidate, name_candidate)
-        confidence = 0.7
-    if not person and metadata.get("email"):
-        person = person_memory.find_person_by_email(metadata["email"])
-        confidence = 0.6 if person else 0.0
-    if not person and metadata.get("phone"):
-        person = person_memory.find_person_by_phone(metadata["phone"])
-        confidence = 0.6 if person else 0.0
-    ask_name_required = confidence < 0.5
-    if person:
-        emit_event(LOGFILE, "brain_person_identity_resolved", status="ok", person_id=person.get("person_id"))
-    else:
-        emit_event(LOGFILE, "brain_person_identity_uncertain", status="ok")
-    return person, confidence, ask_name_required

package/brain/runtime/memory/person_memory.py

@@ -1,138 +0,0 @@
-from __future__ import annotations
-
-import json
-import sqlite3
-import time
-from typing import Dict, List
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def _connect() -> sqlite3.Connection:
-    path = state_store.data_dir() / "person_memory.db"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(path))
-    conn.row_factory = sqlite3.Row
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS person_memory (
-            person_id TEXT PRIMARY KEY,
-            display_name TEXT,
-            aliases_json TEXT,
-            email_addresses_json TEXT,
-            phone_numbers_json TEXT,
-            interaction_count INTEGER DEFAULT 0,
-            trust_score REAL DEFAULT 0.5,
-            trust_level TEXT DEFAULT 'operator',
-            expertise_tags_json TEXT,
-            communication_style_json TEXT,
-            last_seen TEXT,
-            relationship_type TEXT,
-            notes_json TEXT,
-            created_at TEXT
-        )
-        """
-    )
-    _ensure_columns(conn)
-    return conn
-
-
-def _ensure_columns(conn: sqlite3.Connection) -> None:
-    existing = {row[1] for row in conn.execute("PRAGMA table_info(person_memory)")}
-    columns = {
-        "trust_level": "ALTER TABLE person_memory ADD COLUMN trust_level TEXT DEFAULT 'operator'",
-        "expertise_tags_json": "ALTER TABLE person_memory ADD COLUMN expertise_tags_json TEXT",
-        "communication_style_json": "ALTER TABLE person_memory ADD COLUMN communication_style_json TEXT",
-        "relationship_type": "ALTER TABLE person_memory ADD COLUMN relationship_type TEXT",
-        "notes_json": "ALTER TABLE person_memory ADD COLUMN notes_json TEXT",
-        "created_at": "ALTER TABLE person_memory ADD COLUMN created_at TEXT",
-    }
-    for name, ddl in columns.items():
-        if name not in existing:
-            conn.execute(ddl)
-
-
-def create_person(person_id: str, display_name: str = "") -> Dict[str, object]:
-    conn = _connect()
-    conn.execute(
-        """
-        INSERT OR IGNORE INTO person_memory (
-            person_id, display_name, aliases_json, email_addresses_json, phone_numbers_json,
-            interaction_count, trust_score, trust_level, expertise_tags_json, communication_style_json,
-            last_seen, relationship_type, notes_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            person_id,
-            display_name,
-            json.dumps([]),
-            json.dumps([]),
-            json.dumps([]),
-            0,
-            0.5,
-            "operator",
-            json.dumps([]),
-            json.dumps({}),
-            time.strftime("%Y-%m-%d %H:%M:%S"),
-            "",
-            json.dumps([]),
-            time.strftime("%Y-%m-%d %H:%M:%S"),
-        ),
-    )
-    conn.commit()
-    conn.close()
-    emit_event(LOGFILE, "brain_person_memory_created", status="ok", person_id=person_id)
-    return get_person(person_id) or {}
-
-
-def get_person(person_id: str) -> Dict[str, object] | None:
-    conn = _connect()
-    row = conn.execute("SELECT * FROM person_memory WHERE person_id=?", (person_id,)).fetchone()
-    conn.close()
-    return dict(row) if row else None
-
-
-def update_person(person_id: str, updates: Dict[str, object]) -> None:
-    conn = _connect()
-    fields = []
-    values = []
-    for key, value in updates.items():
-        fields.append(f"{key}=?")
-        values.append(value)
-    if not fields:
-        conn.close()
-        return
-    values.append(person_id)
-    conn.execute(f"UPDATE person_memory SET {', '.join(fields)} WHERE person_id=?", values)
-    conn.commit()
-    conn.close()
-    emit_event(LOGFILE, "brain_person_memory_updated", status="ok", person_id=person_id)
-
-
-def _find_by_json(field: str, value: str) -> Dict[str, object] | None:
-    conn = _connect()
-    rows = conn.execute("SELECT * FROM person_memory").fetchall()
-    conn.close()
-    for row in rows:
-        payload = json.loads(row[field] or "[]")
-        if value in payload:
-            return dict(row)
-    return None
-
-
-def find_person_by_email(email: str) -> Dict[str, object] | None:
-    return _find_by_json("email_addresses_json", email)
-
-
-def find_person_by_phone(phone: str) -> Dict[str, object] | None:
-    return _find_by_json("phone_numbers_json", phone)
-
-
-def list_people(limit: int = 50) -> List[Dict[str, object]]:
-    conn = _connect()
-    rows = conn.execute("SELECT * FROM person_memory ORDER BY last_seen DESC LIMIT ?", (limit,)).fetchall()
-    conn.close()
-    return [dict(row) for row in rows]

package/brain/runtime/memory/sentiment_memory.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-import sqlite3
-import time
-from typing import Dict, List
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-from brain.runtime.memory import person_memory
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-SENTIMENTS = {"positive", "neutral", "negative", "frustrated", "urgent", "excited"}
-
-
-def classify_sentiment(text: str) -> str:
-    lowered = (text or "").lower()
-    if "urgent" in lowered:
-        return "urgent"
-    if "frustrated" in lowered or "angry" in lowered:
-        return "frustrated"
-    if "excited" in lowered or "great" in lowered:
-        return "excited"
-    if "bad" in lowered:
-        return "negative"
-    if "good" in lowered:
-        return "positive"
-    return "neutral"
-
-
-def _connect() -> sqlite3.Connection:
-    path = state_store.data_dir() / "sentiment_memory.db"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(path))
-    conn.row_factory = sqlite3.Row
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS sentiment_memory (
-            person_id TEXT,
-            sentiment TEXT,
-            timestamp TEXT
-        )
-        """
-    )
-    return conn
-
-
-def update_person_sentiment_baseline(person_id: str, sentiment: str) -> None:
-    sentiment = sentiment if sentiment in SENTIMENTS else "neutral"
-    conn = _connect()
-    conn.execute(
-        "INSERT INTO sentiment_memory (person_id, sentiment, timestamp) VALUES (?, ?, ?)",
-        (person_id, sentiment, time.strftime("%Y-%m-%d %H:%M:%S")),
-    )
-    conn.commit()
-    conn.close()
-    emit_event(LOGFILE, "brain_person_sentiment_updated", status="ok", person_id=person_id)
-
-
-def list_sentiment(person_id: str, limit: int = 10) -> List[Dict[str, str]]:
-    conn = _connect()
-    rows = conn.execute(
-        "SELECT sentiment, timestamp FROM sentiment_memory WHERE person_id=? ORDER BY timestamp DESC LIMIT ?",
-        (person_id, limit),
-    ).fetchall()
-    conn.close()
-    return [dict(row) for row in rows]

package/brain/runtime/memory/tool_catalog.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Dict, Any
-
-from brain.runtime.instrumentation import emit_event
-from brain.runtime import state_store
-from brain.runtime.memory import store
-
-
-def _ensure_table(conn) -> None:
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS tool_catalog (
-            tool_id TEXT PRIMARY KEY,
-            description TEXT,
-            permission_class TEXT,
-            capability_tags TEXT,
-            first_seen TEXT DEFAULT (datetime('now')),
-            last_used TEXT
-        )
-        """
-    )
-
-
-def record_tool_metadata(metadata: Dict[str, Any]) -> None:
-    conn = store.connect()
-    _ensure_table(conn)
-    tool_id = metadata.get("tool_id")
-    description = metadata.get("description", "")
-    permission_class = metadata.get("permission_class", "restricted")
-    capability_tags = json.dumps(metadata.get("capability_tags", []) or [])
-    conn.execute(
-        """
-        INSERT INTO tool_catalog (tool_id, description, permission_class, capability_tags)
-        VALUES (?, ?, ?, ?)
-        ON CONFLICT(tool_id) DO UPDATE SET
-            description=excluded.description,
-            permission_class=excluded.permission_class,
-            capability_tags=excluded.capability_tags
-        """,
-        (tool_id, description, permission_class, capability_tags),
-    )
-    conn.commit()
-    conn.close()
-    emit_event(
-        state_store.reports_dir() / "brain_memory.log.jsonl",
-        "brain_memory_tool_catalog_update",
-        status="ok",
-        tool_id=tool_id,
-    )
-
-
-def record_tool_usage(tool_id: str) -> None:
-    conn = store.connect()
-    _ensure_table(conn)
-    conn.execute(
-        "UPDATE tool_catalog SET last_used=datetime('now') WHERE tool_id=?",
-        (tool_id,),
-    )
-    conn.commit()
-    conn.close()
-    emit_event(
-        state_store.reports_dir() / "brain_memory.log.jsonl",
-        "brain_memory_tool_catalog_update",
-        status="ok",
-        tool_id=tool_id,
-    )