@agentunion/kite 1.0.6 → 1.2.0

package/extensions/services/web/vendor/storage/identity.py

@@ -0,0 +1,312 @@
+"""Identity-based directory storage for calls organized by user and contact."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+from typing import Any
+
+import aiofiles
+
+from .. import config as cfg
+
+
+def get_user_phone() -> str:
+    """Get the user's phone number from config."""
+    return cfg.get("user.phone_number", "") or "unknown"
+
+
+def sanitize_phone(phone: str) -> str:
+    """Sanitize a phone number for use as a directory name.
+
+    Removes +, spaces, dashes, parentheses. Returns digits only.
+    """
+    cleaned = re.sub(r"[^\d]", "", phone)
+    return cleaned or "unknown"
+
+
+def user_dir(user_phone: str) -> Path:
+    """Return the user directory path: data/users/{phone}/"""
+    return cfg.data_dir() / "users" / sanitize_phone(user_phone)
+
+
+def contact_dir(user_phone: str, contact_phone: str) -> Path:
+    """Return the contact directory: data/users/{phone}/contacts/{contact_phone}/"""
+    return user_dir(user_phone) / "contacts" / sanitize_phone(contact_phone)
+
+
+def call_dir(user_phone: str, contact_phone: str, started_at: str | datetime) -> Path:
+    """Return the call directory: .../calls/{20260225-100000}/"""
+    if isinstance(started_at, str):
+        started_at = datetime.fromisoformat(started_at)
+    folder_name = started_at.strftime("%Y%m%d-%H%M%S")
+    return contact_dir(user_phone, contact_phone) / "calls" / folder_name
+
+
+def ensure_call_dir(user_phone: str, contact_phone: str, started_at: str | datetime) -> Path:
+    """Create the call directory structure (including recordings/) and return the path."""
+    path = call_dir(user_phone, contact_phone, started_at)
+    path.mkdir(parents=True, exist_ok=True)
+    (path / "recordings").mkdir(exist_ok=True)
+    return path
+
+
+async def load_user_context(user_phone: str) -> str:
+    """Read all .md files under the user directory, concatenated."""
+    udir = user_dir(user_phone)
+    if not udir.exists():
+        return ""
+    parts: list[str] = []
+    for md_file in sorted(udir.glob("*.md")):
+        try:
+            async with aiofiles.open(md_file, "r", encoding="utf-8") as f:
+                content = await f.read()
+            if content.strip():
+                parts.append(f"## {md_file.stem}\n\n{content.strip()}")
+        except Exception:
+            continue
+    return "\n\n".join(parts)
+
+
+async def load_contact_context(user_phone: str, contact_phone: str) -> str:
+    """Read all .md files under the contact directory, concatenated."""
+    cdir = contact_dir(user_phone, contact_phone)
+    if not cdir.exists():
+        return ""
+    parts: list[str] = []
+    for md_file in sorted(cdir.glob("*.md")):
+        try:
+            async with aiofiles.open(md_file, "r", encoding="utf-8") as f:
+                content = await f.read()
+            if content.strip():
+                parts.append(f"## {md_file.stem}\n\n{content.strip()}")
+        except Exception:
+            continue
+    return "\n\n".join(parts)
+
+
+async def load_recent_summaries(
+    user_phone: str,
+    contact_phone: str,
+    max_count: int = 10,
+    max_days: int = 30,
+) -> str:
+    """Load recent call summaries for a contact, newest first.
+
+    Scans calls/ subdirectories sorted by name (timestamp-based),
+    limited by max_count and max_days.
+    """
+    calls_root = contact_dir(user_phone, contact_phone) / "calls"
+    if not calls_root.exists():
+        return ""
+
+    # Collect call dirs sorted by name descending (newest first)
+    call_dirs = sorted(
+        [d for d in calls_root.iterdir() if d.is_dir()],
+        key=lambda d: d.name,
+        reverse=True,
+    )
+
+    cutoff = datetime.now(timezone.utc) - timedelta(days=max_days)
+    parts: list[str] = []
+
+    for cdir in call_dirs:
+        if len(parts) >= max_count:
+            break
+
+        # Parse dir name to check date cutoff
+        try:
+            dir_dt = datetime.strptime(cdir.name, "%Y%m%d-%H%M%S").replace(
+                tzinfo=timezone.utc
+            )
+            if dir_dt < cutoff:
+                break  # dirs are sorted newest first, so we can stop
+        except ValueError:
+            continue
+
+        summary_path = cdir / "summary.md"
+        if not summary_path.exists():
+            continue
+
+        try:
+            async with aiofiles.open(summary_path, "r", encoding="utf-8") as f:
+                content = await f.read()
+            if content.strip():
+                parts.append(f"### {cdir.name}\n\n{content.strip()}")
+        except Exception:
+            continue
+
+    return "\n\n".join(parts)
+
+
+async def save_call_message(call_path: Path, entry: dict[str, Any]) -> None:
+    """Append a message entry to messages.jsonl in the call directory."""
+    filepath = call_path / "messages.jsonl"
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    async with aiofiles.open(filepath, "a", encoding="utf-8") as f:
+        await f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+
+async def save_call_summary(call_path: Path, summary: str) -> None:
+    """Write summary.md in the call directory."""
+    filepath = call_path / "summary.md"
+    async with aiofiles.open(filepath, "w", encoding="utf-8") as f:
+        await f.write(summary)
+
+
+async def save_session_info(call_path: Path, session: dict[str, Any]) -> None:
+    """Write session.json in the call directory."""
+    filepath = call_path / "session.json"
+    async with aiofiles.open(filepath, "w", encoding="utf-8") as f:
+        await f.write(json.dumps(session, ensure_ascii=False, indent=2))
+
+
+async def load_call_summary(call_path: Path) -> str | None:
+    """Read summary.md from a call directory."""
+    filepath = call_path / "summary.md"
+    if not filepath.exists():
+        return None
+    async with aiofiles.open(filepath, "r", encoding="utf-8") as f:
+        return await f.read()
+
+
+def get_recording_path(call_path: Path) -> Path | None:
+    """Return the first .wav file in recordings/ under the call directory, or None."""
+    rec_dir = call_path / "recordings"
+    if not rec_dir.exists():
+        return None
+    for wav in rec_dir.glob("*.wav"):
+        return wav
+    return None
+
+
+async def load_call_messages(call_path: Path) -> list[dict[str, Any]]:
+    """Read all messages from messages.jsonl in a call directory."""
+    filepath = call_path / "messages.jsonl"
+    if not filepath.exists():
+        return []
+    records: list[dict[str, Any]] = []
+    async with aiofiles.open(filepath, "r", encoding="utf-8") as f:
+        async for line in f:
+            line = line.strip()
+            if line:
+                try:
+                    records.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+    return records
+
+
+# ---------------------------------------------------------------------------
+# Tools & permissions helpers
+# ---------------------------------------------------------------------------
+
+def load_tools_config(path: Path) -> dict[str, Any] | None:
+    """Read a tools.yaml file and return its contents, or None if missing."""
+    if not path.exists():
+        return None
+    try:
+        import yaml
+        with open(path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception:
+        return None
+
+
+def load_contact_profile(user_phone: str, contact_phone: str) -> dict[str, Any] | None:
+    """Read the contact's profile.yaml and return its contents, or None if missing."""
+    profile_path = contact_dir(user_phone, contact_phone) / "profile.yaml"
+    if not profile_path.exists():
+        return None
+    try:
+        import yaml
+        with open(profile_path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception:
+        return None
+
+
+def _get_owners_list() -> list[dict[str, Any]]:
+    """Return the ``user.owners`` list from config, normalised.
+
+    Supports both the new format (list of dicts) and the legacy
+    ``user.owner_ids`` format (list of phone strings) for backwards
+    compatibility.
+    """
+    owners = cfg.get("user.owners", []) or []
+    if owners:
+        # Normalise: if someone put a plain string in the list, wrap it
+        return [
+            o if isinstance(o, dict) else {"phone": str(o)}
+            for o in owners
+        ]
+    # Fallback: legacy owner_ids
+    owner_ids = cfg.get("user.owner_ids", []) or []
+    return [{"phone": str(oid)} for oid in owner_ids]
+
+
+def is_owner(user_phone: str, contact_phone: str) -> bool:
+    """Check if the contact is an owner.
+
+    Single source of truth: ``config.yaml`` → ``user.owners``.
+    """
+    clean_contact = sanitize_phone(contact_phone)
+    return any(
+        sanitize_phone(o.get("phone", "")) == clean_contact
+        for o in _get_owners_list()
+    )
+
+
+def get_owner_info(contact_phone: str) -> dict[str, Any] | None:
+    """Return the owner config entry for *contact_phone*, or ``None``.
+
+    The returned dict may contain ``phone``, ``name``, ``note``, etc.
+    """
+    clean = sanitize_phone(contact_phone)
+    for o in _get_owners_list():
+        if sanitize_phone(o.get("phone", "")) == clean:
+            return o
+    return None
+
+
+def ensure_contact_profile(
+    user_phone: str,
+    contact_phone: str,
+    contact_name: str | None = None,
+) -> Path:
+    """Ensure the contact directory and profile.yaml exist.
+
+    Creates ``profile.yaml`` with basic contact info on first encounter.
+    If the contact is an owner and the owner config has a ``name``, that
+    name is used as the default (caller-supplied *contact_name* takes
+    priority).
+
+    Owner status is NOT written here — it is determined solely by
+    ``config.user.owners`` at runtime.
+
+    Returns the contact directory path.
+    """
+    import yaml
+
+    cdir = contact_dir(user_phone, contact_phone)
+    cdir.mkdir(parents=True, exist_ok=True)
+
+    profile_path = cdir / "profile.yaml"
+
+    if not profile_path.exists():
+        # Try to pull name from owner config
+        name = contact_name
+        if not name:
+            owner = get_owner_info(contact_phone)
+            if owner:
+                name = owner.get("name", "")
+        profile: dict[str, Any] = {
+            "name": name or "",
+            "phone": contact_phone,
+        }
+        with open(profile_path, "w", encoding="utf-8") as f:
+            yaml.dump(profile, f, allow_unicode=True, default_flow_style=False)
+
+    return cdir