import os
from hydra_db import HydraDB

API_KEY   = os.environ["HYDRA_DB_API_KEY"]
TENANT_ID = "chief-of-staff"

client = HydraDB(token=API_KEY)

def create_tenant():
    """Create the main tenant. Idempotent - safe to call multiple times."""
    client.tenant.create(tenant_id=TENANT_ID)
    print(f"Tenant '{TENANT_ID}' ready.")

# Sub-tenants scope functions per team. Created automatically on first write.
# Sales agents only see sales functions. Engineering agents only see deploy functions.
# Examples:
#   sub_tenant_id = "sales"        → CRM, calendar, email, proposals
#   sub_tenant_id = "engineering"  → deploys, incidents, GitHub, monitoring
#   sub_tenant_id = "executive"    → board decks, reporting, scheduling
#   sub_tenant_id = "hr"           → hiring, onboarding, HRIS actions

if __name__ == "__main__":
    create_tenant()

{
  "id": "send_slack_message",
  "name": "Send a Slack message",
  "description": "Posts a message to a Slack channel or DM on behalf of the user. Use this when the user wants to notify a team, send an update, share information with a colleague, or make an announcement. Prefer this over send_email for internal, time-sensitive, or informal communications.",
  "parameters": {
    "type": "object",
    "properties": {
      "channel":   { "type": "string",  "description": "#channel-name or @username or user ID" },
      "text":      { "type": "string",  "description": "Message body - supports Slack mrkdwn" },
      "thread_ts": { "type": "string",  "description": "Optional. Reply in thread by passing parent message ts." }
    },
    "required": ["channel", "text"]
  },
  "auth": {
    "oauth_provider": "slack",
    "scopes": ["chat:write"]
  },
  "meta": {
    "collections":       ["communication", "slack"],
    "side_effects":      "Sends a visible message. Cannot be unsent programmatically.",
    "idempotent":        false,
    "permissions":       ["all_users"],
    "business_hours_only": false
  }
}

{
  "id": "approve_expense",
  "name": "Approve an expense report",
  "description": "Approves a pending expense report in the finance system. Use when a manager or finance lead needs to sign off on submitted expenses. Always confirm the amount and submitter before calling. Do not suggest this function outside business hours or for users without manager-level permissions.",
  "parameters": {
    "type": "object",
    "properties": {
      "expense_id":  { "type": "string", "description": "Expense report ID from finance system" },
      "approver_id": { "type": "string", "description": "User ID of the approving manager" },
      "note":        { "type": "string", "description": "Optional approval note for audit log" }
    },
    "required": ["expense_id", "approver_id"]
  },
  "meta": {
    "department":         "finance",
    "permission_level":   "manager",
    "cost_threshold":     5000,         // escalate to CFO above this
    "business_hours_only": true,
    "collections":        ["finance", "approvals"],
    "side_effects":       "Triggers payment processing. Irreversible without finance team intervention.",
    "idempotent":         false
  }
}

import json, time, os
from hydra_db import HydraDB

# All functions in the workspace. Each schema loaded from its own file.
FUNCTION_SCHEMAS = [
    "schemas/send_slack_message.json",
    "schemas/send_email.json",
    "schemas/create_calendar_event.json",
    "schemas/update_crm_opportunity.json",
    "schemas/create_jira_ticket.json",
    "schemas/approve_expense.json",
    "schemas/trigger_deployment.json",
    "schemas/notify_pagerduty.json",
    "schemas/generate_report.json",
    "schemas/add_to_notion.json",
]

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"


def load_schema(path: str) -> dict:
    with open(path) as f:
        return json.load(f)

def upload_functions(schema_paths: list, sub_tenant_id: str = "functions") -> list:
    """
    Upload function schemas to HydraDB as knowledge objects.
    sub_tenant_id: scopes which agents can see these functions.
    Use per-team sub-tenants to limit scope and improve routing precision.

    Tip: re-running this is idempotent - HydraDB upserts on 'id'.
    """
    batch   = []
    all_ids = []

    for path in schema_paths:
        schema = load_schema(path)
        fn_id  = schema["id"]

        batch.append({
            "id":        fn_id,
            "title":     schema["name"],
            "type":      "function",     # tells HydraDB this is callable
            "timestamp": "2025-01-01T00:00:00Z",
            "content":   {"text": json.dumps(schema, indent=2)},
            "metadata": {
                "type":         "function",
                "collections":  schema.get("meta", {}).get("collections", []),
                "department":   schema.get("meta", {}).get("department", "all"),
                "permissions":  schema.get("meta", {}).get("permissions", ["all_users"]),
                "idempotent":   schema.get("meta", {}).get("idempotent", True),
                "side_effects": schema.get("meta", {}).get("side_effects", ""),
            },
        })

        if len(batch) == 20:
            all_ids += _upload_batch(batch, sub_tenant_id)
            batch = []; time.sleep(1)

    if batch:
        all_ids += _upload_batch(batch, sub_tenant_id)

    print(f"Functions: {len(all_ids)} schemas indexed.")
    return all_ids


def _upload_batch(batch: list, sub_tenant_id: str) -> list:
    data = client.upload.knowledge(
        tenant_id=TENANT_ID,
        sub_tenant_id=sub_tenant_id,
        app_knowledge=json.dumps(batch),
    )
    return [item.source_id for item in (data.results or []) if item.source_id]


# Upload all functions (all teams, scoped to "functions" sub-tenant)
# For team-scoped variants, call again with sub_tenant_id="sales", "engineering", etc.
if __name__ == "__main__":
    upload_functions(FUNCTION_SCHEMAS, sub_tenant_id="functions")

import json, os
from hydra_db import HydraDB

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"


def deprecate_function(fn_id: str, sub_tenant_id: str, reason: str):
    """
    Mark a function as deprecated so HydraDB stops suggesting it.
    Never delete - old executions reference this ID for audit and provenance.
    Use 'deprecated: true' in metadata + upload new version as fn_id_v2.
    """
    client.upload.knowledge(
        tenant_id=TENANT_ID,
        sub_tenant_id=sub_tenant_id,
        app_knowledge=json.dumps([{
            "id":        fn_id,
            "title":     f"[DEPRECATED] {fn_id}",
            "type":      "function",
            "timestamp": "2025-01-01T00:00:00Z",
            "content":   {"text": f"DEPRECATED: {reason}. Use {fn_id}_v2 instead."},
            "metadata": {
                "deprecated":         True,
                "deprecated_reason":  reason,
                "successor_id":       f"{fn_id}_v2",
            },
        }]),
    )
    print(f"Deprecated {fn_id}. Successor: {fn_id}_v2")


# Example: old create_calendar_event used Google Calendar v3 API (now sunset)
# New version uses Google Calendar v4 with conferencing support
deprecate_function(
    fn_id="create_calendar_event",
    sub_tenant_id="functions",
    reason="Google Calendar v3 API sunset. Migrated to v4 with conferencing support.",
)

import uuid, json, os
from openai import OpenAI
from hydra_db import HydraDB

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"

class ChiefOfStaffOrchestrator:
    """
    The Orchestrator bridges HydraDB function suggestions and real workspace APIs.
    It does NOT decide which function to call - that is HydraDB's job.
    It does: authorize, inject tokens, execute, log outcomes.
    """

    def __init__(self, registry: dict, policy_engine, auth_vault):
        """
        registry:     Map of function_id → callable that executes the real API call.
        policy_engine: Object with .check(user, function_id, params) → bool
        auth_vault:   Object with .get_token(user_id, oauth_provider) → str
        """
        self.registry      = registry
        self.policy        = policy_engine
        self.vault         = auth_vault
        self.llm           = OpenAI()

    def handle_task(
        self,
        task:        str,   # natural language - "book a 30-min call with alice next tuesday"
        user_id:     str,
        session_id:  str = None,
        sub_tenant:  str = "functions",
    ) -> dict:
        """
        Single-function task handling.
        1. Ask HydraDB which function to call.
        2. Authorize against policy engine.
        3. Inject OAuth token from vault.
        4. Execute via registry callable.
        5. Log result back to HydraDB as memory.
        """
        session_id = session_id or str(uuid.uuid4())

        # Step 1 - Ask HydraDB for the best function
        recall = client.recall.full_recall(
            tenant_id=TENANT_ID,
            sub_tenant_id=sub_tenant,
            query=task,
            max_results=5,
            mode="thinking",
            metadata_filters={"deprecated": False},
        )

        chunks = recall.chunks or []
        if not chunks:
            return {"status": "no_match", "message": "No function found for this task."}

        # Top chunk is the best-matching function schema
        top_chunk   = chunks[0]
        schema      = json.loads(top_chunk.chunk_content)
        function_id = schema["id"]

        # Step 2 - Authorize: check user permissions against policy engine
        if not self.policy.check(user_id, function_id, schema):
            self._log_blocked(user_id, task, function_id)
            return {"status": "blocked", "reason": "Policy engine denied this function for your role."}

        # Step 3 - Resolve parameters: use LLM to extract params from task + schema
        params = self._extract_params(task, schema, user_id, session_id)

        # Step 4 - Inject OAuth token for the function's provider
        oauth_provider = schema.get("auth", {}).get("oauth_provider")
        if oauth_provider:
            params["_token"] = self.vault.get_token(user_id, oauth_provider)

        # Step 5 - Execute via registry
        exec_fn = self.registry.get(function_id)
        if not exec_fn:
            return {"status": "error", "message": f"No executor registered for {function_id}."}

        result = exec_fn(params)

        # Step 6 - Log outcome to HydraDB memory for self-improvement
        self._log_execution(user_id, task, function_id, params, result)

        return {"status": "done", "function_id": function_id, "result": result}


    def _extract_params(self, task: str, schema: dict, user_id: str, session_id: str) -> dict:
        """
        Extract structured parameters locally after HydraDB has selected the function.
        HydraDB should be used for retrieval (`/recall/full_recall`); parameter extraction
        belongs in your app/LLM layer because the schema is already in memory here.
        """
        prompt = (
            "Extract the parameters needed to call this function.\n"
            f"Task: {task}\n"
            f"Function schema: {json.dumps(schema['parameters'])}\n"
            "Return ONLY a valid JSON object with the extracted parameter values."
        )
        response = self.llm.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            temperature=0,
        )
        answer = response.choices[0].message.content or "{}"
        try:
            return json.loads(answer)
        except json.JSONDecodeError:
            return {}


    def _log_execution(self, user_id, task, function_id, params, result):
        """Log execution outcome back to HydraDB. Closes the learning loop."""
        success = result.get("success", True)
        outcome = "success" if success else "failure"
        client.upload.add_memory(
            tenant_id=TENANT_ID,
            sub_tenant_id=f"user-{user_id}",
            upsert=True,
            memories=[{
                "text": (
                    f"Task: {task}\n"
                    f"Function used: {function_id}\n"
                    f"Outcome: {outcome}\n"
                    f"Summary: {str(result.get('summary',''))[:300]}"
                ),
                "user_name": user_id,
                "infer": True,
            }],
        )

    def _log_blocked(self, user_id, task, function_id):
        """Log a blocked attempt for audit trail."""
        client.upload.add_memory(
            tenant_id=TENANT_ID,
            upsert=True,
            memories=[{
                "text": f"BLOCKED: User {user_id} attempted {function_id} for task: {task}. Policy denied.",
                "user_name": "audit-log",
                "infer": False,
            }],
        )

from slack_sdk import WebClient
from googleapiclient.discovery import build as google_build
import backoff

def execute_send_slack_message(params: dict) -> dict:
    """
    Execute send_slack_message using the injected OAuth token.
    params["_token"] injected by Orchestrator from auth vault.
    Idempotent on retry: Slack's API deduplicates with the same text in 5s.
    """
    token   = params.pop("_token", None)
    client  = WebClient(token=token)
    channel = params["channel"]
    text    = params["text"]
    kwargs  = {"channel": channel, "text": text}
    if params.get("thread_ts"):
        kwargs["thread_ts"] = params["thread_ts"]
    resp = client.chat_postMessage(**kwargs)
    return {"success": True, "ts": resp["ts"], "channel": resp["channel"],
            "summary": f"Slack message sent to {channel}."}


@backoff.on_exception(backoff.expo, Exception, max_tries=3)
def execute_create_calendar_event(params: dict) -> dict:
    """
    Create a Google Calendar event via the Calendar API v3.
    Exponential back-off handles transient 429s and 500s automatically.
    """
    token    = params.pop("_token", None)
    service  = google_build("calendar", "v3", credentials=token)
    event    = {
        "summary":     params.get("title", "Meeting"),
        "start":       {"dateTime": params["start_time"], "timeZone": params.get("timezone", "UTC")},
        "end":         {"dateTime": params["end_time"],   "timeZone": params.get("timezone", "UTC")},
        "attendees":   [{"email": e} for e in params.get("attendees", [])],
        "description": params.get("description", ""),
    }
    result = service.events().insert(calendarId="primary", body=event, sendUpdates="all").execute()
    return {"success": True, "event_id": result["id"], "link": result.get("htmlLink"),
            "summary": f"Calendar event '{result['summary']}' created."}


# Registry: maps function_id → executor callable
FUNCTION_REGISTRY = {
    "send_slack_message":     execute_send_slack_message,
    "create_calendar_event":  execute_create_calendar_event,
    # "send_email":             execute_send_email,
    # "update_crm_opportunity": execute_update_crm,
    # "create_jira_ticket":     execute_create_jira_ticket,
    # "approve_expense":        execute_approve_expense,
    # "trigger_deployment":     execute_trigger_deployment,
}

import os
from hydra_db import HydraDB

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"


def log_function_feedback(
    user_id:     str,
    function_id: str,
    task:        str,
    outcome:     str,   # "success" | "failure" | "slow" | "user_rejected"
    latency_ms:  int = 0,
    details:     str = "",
):
    """
    Write execution feedback as a memory so HydraDB learns from outcomes.
    infer: true - HydraDB extracts preference signals and builds graph links
    between this user, this function, and similar tasks.

    outcome="user_rejected" is especially valuable: the agent suggested the
    wrong function, the user corrected it. That correction shifts the routing
    weight for this user's context in future calls.
    """
    text = (
        f"Function: {function_id}\n"
        f"Task: {task}\n"
        f"Outcome: {outcome}\n"
        f"Latency: {latency_ms}ms\n"
    )
    if details:
        text += f"Details: {details}"

    client.upload.add_memory(
        tenant_id=TENANT_ID,
        sub_tenant_id=f"user-{user_id}",
        upsert=True,
        memories=[{
            "text":      text,
            "user_name": user_id,
            "infer":     True,
        }],
    )


# Usage: called automatically by the Orchestrator's _log_execution method.
# Also call explicitly for user-driven corrections:
log_function_feedback(
    user_id="sarah",
    function_id="send_email",
    task="tell the team the deploy is done",
    outcome="user_rejected",
    details="Sarah always uses Slack for internal updates, not email. Corrected to send_slack_message.",
)
# → HydraDB learns: for Sarah, "tell the team" maps to send_slack_message

import os
from hydra_db import HydraDB

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"


def store_user_preferences(user_id: str, profile: str):
    """
    Store a user's working preferences so HydraDB personalizes function
    suggestions for them. infer: true - HydraDB extracts channel preferences,
    urgency signals, communication style, and links these to specific functions.

    Call during onboarding and whenever preferences change.
    Use the same user_id consistently across all memory writes for this user.
    """
    client.upload.add_memory(
        tenant_id=TENANT_ID,
        sub_tenant_id=f"user-{user_id}",
        upsert=True,
        memories=[{
            "text":      profile,
            "user_name": user_id,
            "infer":     True,
        }],
    )


# Onboard team members - called once per user at setup, then updated as needed
store_user_preferences(
    user_id="sarah",
    profile=(
        "Sarah is the VP of Engineering. She prefers Slack DMs over email for all internal "
        "communication. For urgent issues she always uses PagerDuty, not Jira. "
        "She approves expenses only during business hours. "
        "Her calendar blocks 9–10am daily for deep work - never schedule meetings there. "
        "She likes executive summaries, not raw data. Always call generate_report before "
        "presenting metrics to her."
    ),
)

store_user_preferences(
    user_id="james",
    profile=(
        "James is an Account Executive on the sales team. He prefers email for external "
        "communications and Slack for internal ones. He runs a lot of demos - when he says "
        "'prepare for a call', always check the CRM for the prospect's deal stage first. "
        "He is in the Pacific timezone. Do not schedule past 5pm his time. "
        "He always CC's his manager when sending proposals."
    ),
)

from datetime import datetime, timezone
from hydra_db import HydraDB
import os

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"

def log_execution_outcome(
    user_id:     str,
    task:        str,
    function_id: str,
    outcome:     str,         # "success" | "failure" | "timeout" | "user_rejected"
    latency_ms:  int,
    error_msg:   str = "",
    chained_fns: list = None,   # other functions called in the same task
):
    """
    Log an execution outcome verbatim (infer: false) for the audit trail.
    Also write a synthesized pattern summary (infer: true) for learning.
    These two writes serve different purposes:
      - infer: false → exact record, queryable for compliance and audit
      - infer: true  → HydraDB extracts patterns and links to similar tasks
    """
    ts = datetime.now(timezone.utc).isoformat()

    # Write 1: exact record
    client.upload.add_memory(
        tenant_id=TENANT_ID,
        sub_tenant_id="execution-log",
        upsert=True,
        memories=[{
            "text": (
                f"[{ts}] user={user_id} fn={function_id} "
                f"outcome={outcome} latency={latency_ms}ms\n"
                f"task={task}\n"
                f"chained={chained_fns or []}\n"
                f"error={error_msg or 'none'}"
            ),
            "user_name": "system",
            "infer":     False,
        }],
    )

    # Write 2: synthesized pattern (only for notable events)
    if outcome in ("failure", "timeout", "user_rejected") or latency_ms > 3000:
        summary = (
            f"{function_id} returned {outcome} for task type '{task[:80]}'. "
        )
        if latency_ms > 3000:
            summary += f"Latency was {latency_ms}ms - above 3s threshold. "
        if error_msg:
            summary += f"Error: {error_msg}. "
        if outcome == "user_rejected":
            summary += f"User manually overrode this suggestion for user_id={user_id}."

        client.upload.add_memory(
            tenant_id=TENANT_ID,
            sub_tenant_id=f"user-{user_id}",
            upsert=True,
            memories=[{
                "text":      summary,
                "user_name": user_id,
                "infer":     True,
            }],
        )

import json, os
from openai import OpenAI
from hydra_db import HydraDB

openai_client = OpenAI()
client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"

def generate_execution_plan(
    task:       str,
    user_id:    str,
    sub_tenant: str = "functions",
    max_steps:  int = 8,
) -> list:
    """
    Generate a multi-step execution plan for a complex task.
    1. Recall the most relevant functions from HydraDB using mode: "thinking".
    2. Pass the ranked functions + task to an LLM for sequencing.
    3. Return a structured plan: [{step, function_id, params, depends_on}].

    max_steps: cap the plan length to avoid runaway chains.
    """
    # Step 1: recall candidate functions with thinking mode
    recall = client.recall.full_recall(
        tenant_id=TENANT_ID,
        sub_tenant_id=sub_tenant,
        query=task,
        max_results=12,
        mode="thinking",
        graph_context=True,
        metadata_filters={"deprecated": False},
    )

    chunks = recall.chunks or []
    if not chunks:
        return []

    # Build the function catalogue string for the planner
    fn_catalogue = "\n\n".join(
        f"FUNCTION {i+1}: {c.source_title}\n{c.chunk_content[:600]}"
        for i, c in enumerate(chunks)
    )

    # Recall user preferences to personalise the plan
    user_prefs = client.recall.recall_preferences(
        tenant_id=TENANT_ID,
        sub_tenant_id=f"user-{user_id}",
        query="channel preferences urgency communication style",
        mode="thinking",
    )

    # Step 2: use LLM to sequence the plan
    resp = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a task planner. Given a task and a catalogue of available functions, "
                    "produce a minimal, ordered execution plan. "
                    "Return ONLY valid JSON: a list of objects with keys: "
                    "step (int), function_id (str), params (object), depends_on (list of step ints), reason (str). "
                    "Maximum steps: " + str(max_steps) + ". "
                    "Use user preferences to choose the right channels and timing. "
                    "Only include functions that are strictly necessary."
                ),
            },
            {
                "role": "user",
                "content": (
                    f"Task: {task}\n\n"
                    f"User preferences: {user_prefs}\n\n"
                    f"Available functions:\n{fn_catalogue}"
                ),
            },
        ],
        temperature=0.1,
    )

    try:
        plan = json.loads(resp.choices[0].message.content)
        return plan
    except (json.JSONDecodeError, KeyError):
        return []


# Usage
plan = generate_execution_plan(
    task="Onboard Alex Chen who starts Monday as a backend engineer on the payments team.",
    user_id="sarah",
)
# → [
#    {step:1, function_id:"create_gsuite_account",    params:{...}, depends_on:[], reason:"..."},
#    {step:2, function_id:"create_jira_account",      params:{...}, depends_on:[1], reason:"..."},
#    {step:3, function_id:"create_github_access",     params:{...}, depends_on:[1], reason:"..."},
#    {step:4, function_id:"send_slack_message",        params:{channel:"#engineering",...}, depends_on:[1,2,3], reason:"..."},
#    {step:5, function_id:"create_calendar_event",    params:{title:"Orientation...",...}, depends_on:[1], reason:"..."},
#    {step:6, function_id:"send_email",               params:{to:"[email protected]",...}, depends_on:[1,2,3,4], reason:"..."},
#  ]

def execute_plan(
    plan:        list,    # [{step, function_id, params, depends_on, reason}]
    user_id:     str,
    orchestrator,
) -> dict:
    """
    Execute a plan in dependency order.
    Outputs from completed steps are available to downstream steps
    via the results dict keyed by step number.
    Stops on first failure unless the step is marked optional.
    """
    results    = {}   # step_number → execution result
    completed  = set()
    failed     = set()

    def _ready(step: dict) -> bool:
        """A step is ready when all its dependencies have completed successfully."""
        return all(d in completed for d in step.get("depends_on", []))

    remaining = list(plan)
    max_iterations = len(plan) * 2   # guard against circular deps
    iterations = 0

    while remaining and iterations < max_iterations:
        iterations += 1
        progress = False

        for step in list(remaining):
            if not _ready(step): continue

            step_num    = step["step"]
            function_id = step["function_id"]
            params      = dict(step.get("params", {}))

            # Inject outputs from dependency steps into params
            for dep_step in step.get("depends_on", []):
                dep_result = results.get(dep_step, {}).get("result", {})
                params.update({
                    k: v for k, v in dep_result.items()
                    if k in params.get("_inject_from_deps", {})
                })

            print(f"  Step {step_num}: {function_id} - {step.get('reason','')[:60]}")

            result = orchestrator.registry.get(function_id, lambda p: {"success": False, "error": "not registered"})(params)
            results[step_num] = {"function_id": function_id, "result": result}

            if result.get("success", False):
                completed.add(step_num)
            else:
                failed.add(step_num)
                print(f"  Step {step_num} FAILED: {result.get('error','unknown error')}")
                if not step.get("optional", False):
                    return {"status": "failed", "failed_step": step_num, "results": results}

            remaining.remove(step)
            progress = True

        if not progress:
            break   # circular dependency or all remaining steps blocked

    return {"status": "complete", "completed": list(completed), "failed": list(failed), "results": results}

# Compensation registry: maps function_id → compensation callable
# Compensation functions undo the side effects of their paired function.
# Not every function has a compensation - mark those as non-compensatable.
COMPENSATION_REGISTRY = {
    "create_gsuite_account":   lambda r: delete_gsuite_account(r.get("account_id")),
    "create_jira_account":    lambda r: delete_jira_account(r.get("jira_id")),
    "create_github_access":   lambda r: revoke_github_access(r.get("username")),
    "create_calendar_event":  lambda r: delete_calendar_event(r.get("event_id")),
    # "send_slack_message":    None,  - cannot be meaningfully rolled back
    # "send_email":            None,  - cannot be recalled programmatically
}

def rollback_plan(results: dict, failed_step: int):
    """
    Compensate for completed steps in reverse order after a failure.
    Skips steps without a compensation function.
    Logs each compensation attempt to HydraDB's execution-log sub-tenant.
    """
    completed_steps = sorted(
        [s for s in results if s < failed_step], reverse=True
    )
    for step_num in completed_steps:
        entry       = results[step_num]
        function_id = entry["function_id"]
        result      = entry["result"]
        compensate  = COMPENSATION_REGISTRY.get(function_id)

        if compensate:
            try:
                compensate(result)
                print(f"  Rolled back step {step_num}: {function_id}")
                log_execution_outcome(
                    user_id="system", task=f"rollback {function_id}",
                    function_id=f"rollback_{function_id}",
                    outcome="success", latency_ms=0,
                )
            except Exception as e:
                print(f"  Rollback FAILED for step {step_num}: {e}")
        else:
            print(f"  Step {step_num} ({function_id}): no compensation registered. Manual review needed.")

from flask import Flask, request, jsonify
from slack_sdk import WebClient

flask_app  = Flask(__name__)
slack_bot  = WebClient(token=os.environ["SLACK_BOT_TOKEN"])
orchestrator = ChiefOfStaffOrchestrator(
    registry=FUNCTION_REGISTRY,
    policy_engine=PolicyEngine(),
    auth_vault=AuthVault(),
)

# Maps Slack user IDs to internal user IDs (use CRM or HRIS lookup in production)
def slack_to_user_id(slack_uid: str) -> str:
    return f"slack-{slack_uid}"   # simplest - use CRM lookup in production

@flask_app.route("/slack/ai", methods=["POST"])
def handle_slack_ai_command():
    """
    Handles /ai slash-command from Slack.
    /ai book a 30-min call with alice next tuesday
    /ai send the deploy-complete message to #engineering
    /ai prepare for board meeting next Tuesday
    """
    slack_uid  = request.form["user_id"]
    task       = request.form.get("text", "").strip()
    channel    = request.form["channel_id"]
    user_id    = slack_to_user_id(slack_uid)

    if not task:
        return jsonify({"text": "Please describe what you'd like me to do."})

    # Ack immediately so Slack doesn't time out the slash-command (3s limit)
    slack_bot.chat_postEphemeral(
        channel=channel, user=slack_uid,
        text=f"_Working on it: “{task[:80]}…”_"
    )

    # Detect multi-step task and route accordingly
    MULTI_STEP_SIGNALS = ["prepare", "onboard", "set up", "ship", "launch"]
    is_multi = any(s in task.lower() for s in MULTI_STEP_SIGNALS)

    if is_multi:
        plan   = generate_execution_plan(task, user_id)
        result = execute_plan(plan, user_id, orchestrator)
        steps  = result.get("completed", [])
        reply  = f"Done. Completed {len(steps)} step(s): {', '.join(str(s) for s in steps)}."
    else:
        result = orchestrator.handle_task(task, user_id)
        reply  = result.get("result", {}).get("summary", "Done.")

    slack_bot.chat_postEphemeral(channel=channel, user=slack_uid, text=reply)
    return jsonify({})   # already replied via ephemeral - return empty 200

if __name__ == "__main__":
    flask_app.run(host="0.0.0.0", port=8080)

# Cron: 0 8 * * 1  (Monday 8am UTC) - Weekly executive briefing
def weekly_executive_briefing():
    """
    Generate and deliver a personalized weekly briefing to each exec.
    HydraDB uses each exec's memory profile to select the right
    report type, channel, and level of detail automatically.
    """
    execs = [
        {"user_id": "sarah",   "task": "Generate and send this week's engineering team briefing."},
        {"user_id": "james",   "task": "Generate and send this week's sales pipeline summary."},
        {"user_id": "priya",   "task": "Generate and send this week's customer health report."},
    ]
    for exec_user in execs:
        try:
            plan   = generate_execution_plan(exec_user["task"], exec_user["user_id"])
            result = execute_plan(plan, exec_user["user_id"], orchestrator)
            print(f"Briefing sent to {exec_user['user_id']}: {result['status']}")
        except Exception as e:
            print(f"Briefing failed for {exec_user['user_id']}: {e}")


# Cron: 0 9 * * *  (Daily 9am) - standup prompt for each team channel
def daily_standup_prompt():
    """Send the daily standup prompt to each team channel via Slack."""
    teams = [
        ("eng-lead",   "#engineering"),
        ("design-lead", "#design"),
        ("sales-lead",  "#sales"),
    ]
    for user_id, channel in teams:
        orchestrator.handle_task(
            task=f"Post the daily standup prompt to {channel}.",
            user_id=user_id,
        )

if __name__ == "__main__":
    weekly_executive_briefing()
    daily_standup_prompt()

@flask_app.route("/webhooks/monitoring", methods=["POST"])
def handle_monitoring_alert():
    """
    Receives a monitoring alert and routes it to the correct on-call response.
    HydraDB's memory of past incidents and the team's learned response patterns
    determine whether this triggers immediate escalation or scheduled review.
    """
    data     = request.json
    service  = data.get("service", "unknown")
    severity = data.get("severity", "low")   # "low" | "medium" | "high" | "critical"
    message  = data.get("message", "")

    # Translate the monitoring event into a natural-language task.
    # HydraDB's context graph knows which functions respond to incidents for this service.
    task = (
        f"{severity.upper()} monitoring alert for {service}: {message}. "
        f"Determine the appropriate incident response and take action."
    )

    # For critical alerts: immediately escalate, do not wait for plan generation
    if severity == "critical":
        orchestrator.handle_task(task=task, user_id="oncall-system")
    else:
        # For non-critical: generate a plan (may include "monitor and review at standup")
        plan   = generate_execution_plan(task, user_id="oncall-system")
        execute_plan(plan, user_id="oncall-system", orchestrator=orchestrator)

    return jsonify({"status": "handled"}), 200


@flask_app.route("/webhooks/crm", methods=["POST"])
def handle_crm_event():
    """
    Handles CRM stage-change events.
    When a deal moves to 'Demo Requested', HydraDB suggests:
    check_customer_tier → find_available_demo_slots → create_demo_meeting
    → update_crm_opportunity → send_confirmation_email
    - all from one natural language task description.
    """
    data        = request.json
    deal_id     = data.get("deal_id")
    new_stage   = data.get("new_stage")
    company     = data.get("company_name", "the prospect")
    owner_id    = data.get("deal_owner_id", "sales-lead")

    # Translate CRM event → natural language task
    stage_tasks = {
        "Demo Requested":  f"Schedule a product demo for {company} (deal {deal_id}) and send confirmation.",
        "Proposal Sent":   f"Log a follow-up task in 3 days for {company} deal {deal_id} and set a reminder.",
        "Closed Won":      f"Celebrate the {company} win in Slack, update CRM deal {deal_id}, and trigger onboarding.",
        "Closed Lost":     f"Log loss reason for {company} deal {deal_id} and schedule a retrospective.",
    }
    task = stage_tasks.get(new_stage)
    if task:
        plan   = generate_execution_plan(task, owner_id)
        execute_plan(plan, owner_id, orchestrator)

    return jsonify({"status": "ok"}), 200

from datetime import datetime, timezone

# User role definitions - load from your HRIS or auth system in production
USER_ROLES = {
    "sarah":  {"level": "manager", "departments": ["engineering", "all"]},
    "james":  {"level": "contributor", "departments": ["sales"]},
    "priya":  {"level": "manager", "departments": ["customer-success", "all"]},
}
PERMISSION_HIERARCHY = ["viewer", "contributor", "manager", "admin"]

class PolicyEngine:
    def check(self, user_id: str, function_id: str, schema: dict) -> bool:
        """
        Return True if the user is authorized to call this function.
        Checks: permission_level, department, business_hours, cost_threshold.
        """
        user_role = USER_ROLES.get(user_id, {"level": "viewer", "departments": []})
        meta      = schema.get("meta", {})

        # Check permission level
        required_level = meta.get("permission_level", "contributor")
        user_level     = user_role["level"]
        if PERMISSION_HIERARCHY.index(user_level) < PERMISSION_HIERARCHY.index(required_level):
            print(f"Policy blocked {user_id}: needs {required_level}, has {user_level}.")
            return False

        # Check department scope
        fn_dept       = meta.get("department", "all")
        user_depts    = user_role.get("departments", [])
        if fn_dept != "all" and fn_dept not in user_depts and "all" not in user_depts:
            print(f"Policy blocked {user_id}: {function_id} is department '{fn_dept}'.")
            return False

        # Check business hours constraint
        if meta.get("business_hours_only", False):
            now  = datetime.now(timezone.utc)
            hour = now.hour   # UTC - adjust for user timezone in production
            if not (9 <= hour <= 17) or now.weekday() >= 5:
                print(f"Policy blocked {function_id}: business hours only.")
                return False

        return True

    def requires_approval(self, user_id: str, schema: dict, params: dict) -> bool:
        """
        Return True if this call needs human approval before execution.
        Triggered when: cost exceeds threshold, function has 'requires_approval: true',
        or user is requesting an action outside their normal patterns.
        """
        meta      = schema.get("meta", {})
        threshold = meta.get("cost_threshold", None)
        amount    = params.get("amount", 0)
        if threshold and amount > threshold:
            return True
        return meta.get("requires_approval", False)

import json, os
from hydra_db import HydraDB

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"


def request_approval(
    user_id:     str,
    function_id: str,
    params:      dict,
    task:        str,
    approver_id: str,   # Slack user ID of the approver (their manager, finance, etc.)
) -> str:
    """
    Send an approval request via Slack and store the pending action in HydraDB.
    Returns an approval_id that the approver sends back to resume execution.
    """
    approval_id = str(uuid.uuid4())[:8]

    # Store the pending action in HydraDB so it can be resumed after approval
    client.upload.add_memory(
        tenant_id=TENANT_ID,
        sub_tenant_id="approvals",
        upsert=True,
        memories=[{
            "text": json.dumps({
                "approval_id": approval_id,
                "user_id":     user_id,
                "function_id": function_id,
                "params":      params,
                "task":        task,
                "status":      "pending",
            }),
            "user_name": "approval-system",
            "infer":     False,
        }],
    )

    # Send the Slack approval request to the approver
    slack_bot.chat_postMessage(
        channel=approver_id,
        text=(
            f"*Approval required* [ID: `{approval_id}`]\n"
            f"*Requested by:* {user_id}\n"
            f"*Action:* `{function_id}`\n"
            f"*Task:* {task}\n"
            f"*Params:* ```{json.dumps(params, indent=2)}```\n\n"
            f"Reply `/approve {approval_id}` or `/reject {approval_id} [reason]`"
        ),
    )
    return approval_id

from datetime import datetime, timezone
import json, os
from hydra_db import HydraDB

client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
TENANT_ID = "chief-of-staff"


def report_function_performance(
    function_id: str,
    signal:      str,    # "slow_response" | "frequent_failure" | "high_rejection"
    details:     dict,   # {"p95_ms": 2500, "failure_rate": 0.12, "rejection_rate": 0.22}
):
    """
    Write performance signals to HydraDB's function sub-tenant.
    HydraDB uses these signals to down-weight problematic functions
    in future suggestions without removing them from the registry.
    Combine with function description updates for best results.
    """
    text = (
        f"Performance signal for {function_id}: {signal}.\n"
        f"Details: {json.dumps(details)}\n"
        f"Observed: {datetime.now(timezone.utc).isoformat()}"
    )
    client.upload.add_memory(
        tenant_id=TENANT_ID,
        sub_tenant_id="function-performance",
        upsert=True,
        memories=[{
            "text":      text,
            "user_name": "observability-system",
            "infer":     True,
        }],
    )


# Example - called by a weekly metrics job
report_function_performance(
    function_id="create_calendar_event",
    signal="slow_response",
    details={"p95_ms": 2800, "sample_size": 412, "period": "2025-W22"},
)

report_function_performance(
    function_id="send_email",
    signal="high_rejection",
    details={
        "rejection_rate": 0.34,
        "most_common_correction": "send_slack_message",
        "note": "Users reject email in favour of Slack for 34% of internal tasks.",
    },
)
# → HydraDB learns: for internal communication tasks, weight send_slack_message higher

{ "tenant_id": "chief-of-staff" }

[{
  "id":        "send_slack_message",
  "title":     "Send a Slack message",
  "type":      "function",               // tells HydraDB this is callable
  "timestamp": "2025-01-01T00:00:00Z",
  "content":   { "text": "{ full JSON schema as string }" },
  "metadata": {
    "type":         "function",
    "collections":  ["communication", "slack"],
    "permissions":  ["all_users"],
    "idempotent":   false,
    "side_effects": "Sends a visible Slack message. Cannot be unsent.",
    "deprecated":   false
  }
}]

{
  "tenant_id":     "chief-of-staff",
  "sub_tenant_id": "functions",         // or team-scoped sub-tenant
  "query":         "book a 30-min call with alice next tuesday",
  "max_results":   5,
  "mode":          "thinking",         // multi-query rerank + personalised recall
  "graph_context": false,              // not needed for single function lookup
  "metadata_filters": { "deprecated": false }
}

{
  "tenant_id":     "chief-of-staff",
  "sub_tenant_id": "functions",
  "query":         "Onboard Alex Chen who starts Monday as a backend engineer.",
  "max_results":   12,
  "mode":          "thinking",         // multi-query decomposition for complex tasks
  "graph_context": true,               // surfaces function composition chains
  "metadata_filters": { "deprecated": false }
}

{
  "tenant_id":     "chief-of-staff",
  "sub_tenant_id": "user-sarah",         // per-user sub-tenant
  "query":         "channel preferences urgency communication timing",
  "mode":          "thinking"
}

{
  "memories": [{
    "text":      "Sarah always uses Slack DMs for urgent internal updates, not email.",
    "user_name": "sarah",
    "infer":     true        // extracts channel preference signal
  }],
  "tenant_id":     "chief-of-staff",
  "sub_tenant_id": "user-sarah",
  "upsert":        true
}

{
  "memories": [{
    "text":      "[2025-06-10T09:12:44Z] user=sarah fn=send_slack_message outcome=success latency=180ms",
    "user_name": "system",
    "infer":     false   // verbatim audit record - exact facts, no interpretation
  }],
  "tenant_id":     "chief-of-staff",
  "sub_tenant_id": "execution-log",
  "upsert":        true
}

{
  "memories": [{
    "text":      "create_calendar_event returned slow_response: p95=2800ms over 412 calls in W22.",
    "user_name": "observability-system",
    "infer":     true    // HydraDB links signal to function routing weight
  }],
  "tenant_id":     "chief-of-staff",
  "sub_tenant_id": "function-performance",
  "upsert":        true
}

{
  "task": "ping #engineering that the deploy is done",
  "function_schema": {
    "id": "send_slack_message",
    "parameters": {
      "channel": "string",
      "message": "string"
    }
  },
  "expected_output": {
    "channel": "#engineering",
    "message": "the deploy is done"
  }
}