@adaptic/maestro 1.0.0

package/scripts/pre_draft_lookup.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""Pre-draft context lookup wrapper — Memory Enhancement Phase 7.
+
+Thin wrapper around pre-draft-context.py that:
+  1. Calls retrieve_context() for a recipient
+  2. Logs the result to logs/audit/{date}-pre-draft-lookups.jsonl
+  3. Returns the context dict (or None) without blocking
+
+Designed for import into send scripts. Fail-open: if anything goes wrong,
+logs the error and returns None — never blocks a send.
+
+Usage (Python import):
+    from pre_draft_lookup import pre_draft_lookup
+    context = pre_draft_lookup("Mehran Granfar", message_type="slack")
+
+Usage (CLI — for shell scripts):
+    python3 scripts/pre_draft_lookup.py --recipient "Mehran Granfar" --type slack --channel C099ABC
+
+Created: 2026-04-04 — Memory Enhancement Phase 7
+"""
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+REPO_ROOT = SCRIPT_DIR.parent
+AUDIT_LOG_DIR = REPO_ROOT / "logs" / "audit"
+
+# Import pre-draft-context module (same directory)
+_pdc_module = None
+try:
+    # pre-draft-context.py uses a hyphen in the filename, so we use the
+    # importlib approach or just add the scripts dir to sys.path and
+    # import the module that was saved as pre_draft_context.py equivalent.
+    # Actually, the file is scripts/pre-draft-context.py — we need importlib.
+    import importlib.util
+    pdc_path = SCRIPT_DIR / "pre-draft-context.py"
+    if pdc_path.exists():
+        spec = importlib.util.spec_from_file_location("pre_draft_context", str(pdc_path))
+        _pdc_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(_pdc_module)
+except Exception:
+    pass
+
+# Import disclosure boundaries module (same directory)
+_db_module = None
+try:
+    import importlib.util as _db_ilu
+    _db_path = SCRIPT_DIR / "disclosure_boundaries.py"
+    if _db_path.exists():
+        _db_spec = _db_ilu.spec_from_file_location("disclosure_boundaries", str(_db_path))
+        _db_mod = _db_ilu.module_from_spec(_db_spec)
+        _db_spec.loader.exec_module(_db_mod)
+        generate_disclosure_boundaries = _db_mod.generate_disclosure_boundaries
+        _db_module = True
+except Exception:
+    pass
+
+
+def _log_lookup(record):
+    """Append a lookup record to the daily audit log (JSONL). Best-effort."""
+    try:
+        AUDIT_LOG_DIR.mkdir(parents=True, exist_ok=True)
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        log_path = AUDIT_LOG_DIR / f"{date_str}-pre-draft-lookups.jsonl"
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(record, default=str, ensure_ascii=False) + "\n")
+    except Exception:
+        pass  # Never fail on logging
+
+
+def pre_draft_lookup(recipient, message_type="email", channel=None, topic=None):
+    """Look up recipient context before sending a message.
+
+    Args:
+        recipient: Name, email, or Slack channel ID of the recipient.
+        message_type: "email" or "slack".
+        channel: Optional channel/thread identifier for logging.
+        topic: Optional topic to filter context.
+
+    Returns:
+        dict with context, or None if lookup fails or recipient not found.
+        Never raises — always fail-open.
+    """
+    t0 = time.time()
+    timestamp = datetime.now(timezone.utc).isoformat()
+
+    log_record = {
+        "timestamp": timestamp,
+        "recipient": recipient,
+        "message_type": message_type,
+        "channel": channel,
+        "topic": topic,
+        "status": "error",
+        "entity_found": False,
+        "facts_count": 0,
+        "critical_facts": [],
+        "lookup_ms": 0,
+    }
+
+    if _pdc_module is None:
+        log_record["status"] = "module_unavailable"
+        log_record["error"] = "pre-draft-context.py could not be imported"
+        log_record["lookup_ms"] = round((time.time() - t0) * 1000, 1)
+        _log_lookup(log_record)
+        return None
+
+    try:
+        context = _pdc_module.retrieve_context(recipient, topic)
+        elapsed_ms = round((time.time() - t0) * 1000, 1)
+        log_record["lookup_ms"] = elapsed_ms
+
+        if context is None:
+            log_record["status"] = "not_found"
+            _log_lookup(log_record)
+            return None
+
+        # Context found — extract key details for audit log
+        log_record["status"] = "found"
+        log_record["entity_found"] = True
+
+        r = context.get("recipient", {})
+        log_record["entity_name"] = r.get("name", "")
+        log_record["entity_id"] = r.get("entity_id", "")
+        log_record["relationship_type"] = context.get("relationship", {}).get("type", "")
+        log_record["is_internal"] = context.get("relationship", {}).get("is_internal", False)
+
+        # Count facts
+        facts_count = 0
+        standing = context.get("communication", {}).get("standing_instructions", [])
+        if isinstance(standing, list):
+            facts_count += len(standing)
+        facts_count += len(context.get("active_queue_items", []))
+        facts_count += len(context.get("related_entities", []))
+        facts_count += len(context.get("recent_interactions", []))
+        log_record["facts_count"] = facts_count
+
+        # Extract critical facts — things that could cause errors if ignored
+        critical_facts = []
+        # Check notes for negation patterns (e.g., "NOT a co-founder")
+        notes = r.get("notes", "") or ""
+        if notes:
+            # Flag notes containing "NOT", "never", "do not"
+            for pattern in ["NOT ", "never ", "do not ", "don't ", "is not "]:
+                if pattern.lower() in notes.lower():
+                    critical_facts.append(f"ENTITY NOTE: {notes}")
+                    break
+
+        # Check standing instructions for critical items
+        if isinstance(standing, list):
+            for instr in standing:
+                instr_str = str(instr).lower()
+                if any(w in instr_str for w in ["never", "not ", "don't", "do not", "avoid", "critical"]):
+                    critical_facts.append(f"STANDING INSTRUCTION: {instr}")
+
+        # Check relationship type warnings
+        rel_type = context.get("relationship", {}).get("type", "")
+        adaptic_rels = context.get("relationship", {}).get("adaptic_relationships", [])
+        for ar in adaptic_rels:
+            ar_notes = ar.get("notes", "") or ""
+            if ar_notes and any(w in ar_notes.lower() for w in ["not ", "never", "conditional", "pending"]):
+                critical_facts.append(f"RELATIONSHIP NOTE: {ar_notes}")
+
+        log_record["critical_facts"] = critical_facts
+        if critical_facts:
+            log_record["has_critical_facts"] = True
+
+        # ── Disclosure Boundaries (Information Barrier Layer 1) ──
+        disclosure_boundaries = None
+        if _db_module:
+            try:
+                entity_name = r.get("name", "") or recipient
+                slug = entity_name.lower().replace(" ", "-")
+                disclosure_boundaries = generate_disclosure_boundaries(slug)
+                if disclosure_boundaries:
+                    context["disclosure_boundaries"] = disclosure_boundaries
+                    log_record["disclosure_boundaries_generated"] = True
+                    log_record["active_conflicts_count"] = len(
+                        disclosure_boundaries.get("active_conflicts", [])
+                    )
+                    log_record["excluded_domains_count"] = len(
+                        disclosure_boundaries.get("excluded_domains_active", [])
+                    )
+                    log_record["recent_sensitive_count"] = len(
+                        disclosure_boundaries.get("recent_sensitive_context", [])
+                    )
+            except Exception:
+                log_record["disclosure_boundaries_generated"] = False
+
+        _log_lookup(log_record)
+        return context
+
+    except Exception as e:
+        log_record["status"] = "error"
+        log_record["error"] = str(e)
+        log_record["lookup_ms"] = round((time.time() - t0) * 1000, 1)
+        _log_lookup(log_record)
+        return None
+
+
+def format_context_brief(context):
+    """Format context as a brief string summary. Delegates to pre-draft-context module."""
+    if _pdc_module is None:
+        return ""
+    try:
+        return _pdc_module.format_brief(context)
+    except Exception:
+        return ""
+
+
+# ─────────────────────────────────────────────
+# CLI entry point (for shell script integration)
+# ─────────────────────────────────────────────
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(
+        description="Pre-draft context lookup wrapper — logs results to audit trail."
+    )
+    parser.add_argument("--recipient", required=True, help="Recipient name or email")
+    parser.add_argument("--type", dest="message_type", default="email",
+                        choices=["email", "slack"], help="Message type")
+    parser.add_argument("--channel", default=None, help="Channel/thread ID for logging")
+    parser.add_argument("--topic", default=None, help="Optional topic filter")
+    args = parser.parse_args()
+
+    context = pre_draft_lookup(
+        args.recipient,
+        message_type=args.message_type,
+        channel=args.channel,
+        topic=args.topic,
+    )
+
+    if context is None:
+        print("PRE_DRAFT_LOOKUP: No context found for recipient", file=sys.stderr)
+        sys.exit(0)  # Exit 0 — not finding context is not an error
+
+    brief = format_context_brief(context)
+    if brief:
+        print(f"PRE_DRAFT_CONTEXT:\n{brief}", file=sys.stderr)
+
+    # Output JSON to stdout for potential downstream consumption
+    print(json.dumps({
+        "status": "found",
+        "entity_name": context.get("recipient", {}).get("name", ""),
+        "entity_id": context.get("recipient", {}).get("entity_id", ""),
+        "relationship_type": context.get("relationship", {}).get("type", ""),
+        "facts_count": len(context.get("active_queue_items", [])) +
+                       len(context.get("related_entities", [])) +
+                       len(context.get("recent_interactions", [])),
+    }, default=str))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()