ltcai 11.5.2 → 11.7.0

package/latticeai/api/automation_intelligence.py

@@ -1,401 +0,0 @@
-"""Question-driven everyday automation API router (v9.4.0).
-
-Exposes :class:`~latticeai.services.automation_intelligence.AutomationIntelligenceService`:
-recurring-question patterns with evidence, automation suggestions (from the
-user's own questions and connected knowledge folders), one-click consent-first
-install, and a combined overview for the automation surface.
-
-Installs follow the same consent contract as the starter recipes: the
-workflow is created as a disabled draft (unless the user explicitly asks to
-enable), review-queue gated, local-only, and idempotent per suggestion.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import os
-import time
-from typing import Any, Callable, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-from latticeai.core.quiet import quiet
-from latticeai.services.automation_execution import (
-    build_last_execution,
-    dry_run_report,
-    enqueue_failed_execution,
-    is_automation_workflow,
-    summarize_workflow_run,
-)
-from latticeai.services.automation_intelligence import AutomationIntelligenceService
-from latticeai.services.brain_automation import find_installed_recipe_workflow
-
-
-class SuggestionInstallRequest(BaseModel):
-    suggestion_id: str
-    enabled: bool = False
-
-
-class AutomationRunNowRequest(BaseModel):
-    workflow_id: str
-    # Dry-run first: the default reports what WOULD happen without side
-    # effects; an explicit dry_run=false runs the automation once for real.
-    dry_run: bool = True
-
-
-def _ensure_activity_run_source(run: Any) -> dict[str, Any]:
-    """Guarantee the Act feed ``source`` field for 레시피/목표 badge split.
-
-    Capture 09 (``frontend/src/pages/Act.tsx``) distinguishes workflow vs agent
-    with ``run.source === "workflow" || Boolean(run.workflow_id)``. A store that
-    omits both collapses every row to "목표" and silently undoes the merged
-    timeline redesign. Prefer an explicit ``source``; otherwise infer from
-    ``workflow_id`` / ``agent_id``.
-    """
-    if not isinstance(run, dict):
-        return {"source": "agent", "id": None, "title": "", "status": ""}
-    row = dict(run)
-    source = str(row.get("source") or "").strip().lower()
-    if source in {"workflow", "agent"}:
-        row["source"] = source
-        return row
-    if row.get("workflow_id"):
-        row["source"] = "workflow"
-        return row
-    if row.get("agent_id"):
-        row["source"] = "agent"
-        return row
-    # Last resort: keep any non-empty legacy value, else agent.
-    row["source"] = source if source else "agent"
-    return row
-
-
-def _with_run_truncation_meta(payload: Any, *, capped: int) -> dict[str, Any]:
-    """Guarantee ``total`` / ``truncated`` on combined-run payloads.
-
-    Stores that already implement :meth:`list_combined_runs` may return only
-    ``runs``. The Act feed needs to say how many rows are hidden when the
-    server slices agent+workflow history (default cap 20).
-
-    Every run is also passed through :func:`_ensure_activity_run_source` so the
-    레시피/목표 badge never loses its discriminator.
-    """
-    if not isinstance(payload, dict):
-        return {"runs": [], "total": 0, "truncated": False}
-    runs = [_ensure_activity_run_source(run) for run in (payload.get("runs") or [])]
-    if "total" in payload:
-        try:
-            total = max(0, int(payload.get("total") or 0))
-        except (TypeError, ValueError):
-            total = len(runs)
-    else:
-        total = len(runs)
-    if "truncated" in payload:
-        truncated = bool(payload.get("truncated"))
-    else:
-        truncated = total > len(runs) or total > capped
-    # Prefer the larger of declared total and visible rows so a buggy store
-    # never claims fewer total than the list it just returned.
-    total = max(total, len(runs))
-    if total > len(runs):
-        truncated = True
-    return {**payload, "runs": runs, "total": total, "truncated": truncated}
-
-
-def _run_now_wait_seconds() -> float:
-    raw = os.environ.get("LATTICEAI_AUTOMATION_RUN_NOW_WAIT", "30")
-    try:
-        return max(0.0, min(float(raw), 300.0))
-    except (TypeError, ValueError):
-        return 30.0
-
-
-def create_automation_intelligence_router(
-    *,
-    service: AutomationIntelligenceService,
-    store: Any,
-    require_user: Callable[[Request], str],
-    gate_read: Callable[[Request], Optional[str]],
-    gate_write: Callable[[Request], Optional[str]],
-    append_audit_event: Callable[..., None],
-    workspace_graph: Callable[[], Any],
-    run_executor: Any = None,
-    review_queue: Any = None,
-) -> APIRouter:
-    from lattice_brain.runtime.statuses import RUN_TERMINAL_STATUSES
-    from lattice_brain.workflow import legacy_steps_from_nodes, validate_definition
-
-    router = APIRouter()
-
-    @router.get("/api/automation/patterns")
-    async def automation_patterns(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.question_patterns(user_email=user, workspace_id=scope)
-
-    @router.get("/api/automation/suggestions")
-    async def automation_suggestions(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.suggestions(user_email=user, workspace_id=scope)
-
-    @router.get("/api/automation/overview")
-    async def automation_overview(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.overview(user_email=user, workspace_id=scope)
-
-    @router.post("/api/automation/install")
-    async def automation_install(req: SuggestionInstallRequest, request: Request):
-        user = require_user(request)
-        scope = gate_write(request)
-        suggestion = service.find_suggestion(
-            req.suggestion_id, user_email=user, workspace_id=scope
-        )
-        if suggestion is None:
-            raise HTTPException(
-                status_code=404,
-                detail=f"Automation suggestion not found: {req.suggestion_id}",
-            )
-        definition = service.build_suggestion_workflow(suggestion, enabled=req.enabled)
-
-        # Idempotent per suggestion: reuse the workflow provenance match used
-        # for recipes, keyed on suggestion_id instead of recipe_id.
-        existing = None
-        for workflow in store.list_workflows(workspace_id=scope).get("workflows") or []:
-            metadata = (workflow or {}).get("metadata") or {}
-            if (
-                metadata.get("created_from") == "automation_suggestion"
-                and metadata.get("suggestion_id") == req.suggestion_id
-            ):
-                existing = workflow
-                break
-        if existing is None and suggestion.get("recipe_id"):
-            existing = find_installed_recipe_workflow(
-                store.list_workflows(workspace_id=scope).get("workflows"),
-                suggestion["recipe_id"],
-            )
-        if existing is not None:
-            return {
-                "workflow": existing,
-                "suggestion": suggestion,
-                "enabled": bool((existing.get("metadata") or {}).get("automation_state") == "enabled"),
-                "already_installed": True,
-            }
-
-        errors = validate_definition({"name": definition["name"], "nodes": definition["nodes"]})
-        if errors:
-            raise HTTPException(status_code=400, detail={"validation_errors": errors})
-        workflow = store.create_workflow(
-            name=definition["name"],
-            steps=legacy_steps_from_nodes(definition["nodes"]),
-            nodes=definition["nodes"],
-            metadata=definition["metadata"],
-            user_email=user or None,
-            graph=workspace_graph(),
-            workspace_id=scope,
-        )
-        append_audit_event(
-            "automation_suggestion_installed",
-            user_email=user,
-            workflow_id=workflow.get("id"),
-            suggestion_id=req.suggestion_id,
-            suggestion_kind=suggestion.get("kind"),
-            enabled=bool(req.enabled),
-        )
-        return {
-            "workflow": workflow,
-            "suggestion": suggestion,
-            "enabled": bool(req.enabled),
-            "already_installed": False,
-        }
-
-    def _stamp_last_execution(
-        workflow_id: str, last_execution: dict, scope: Optional[str]
-    ) -> None:
-        """Persist the execution record on the workflow's metadata (merge)."""
-        try:
-            store.update_workflow_definition(
-                workflow_id,
-                metadata={"last_execution": last_execution},
-                workspace_id=scope,
-            )
-        except Exception:  # noqa: BLE001 — surfacing must never undo the run
-            quiet()
-
-    @router.post("/api/automation/run-now")
-    async def automation_run_now(req: AutomationRunNowRequest, request: Request):
-        """Run an installed automation once — dry-run by default.
-
-        * ``dry_run=true``: deterministic report of what WOULD happen; no
-          runner executes and nothing but the ``last_execution`` stamp moves.
-        * ``dry_run=false``: one real execution through the async run
-          executor; the request waits briefly for completion, stamps the
-          result, and enqueues failed executions into the review inbox.
-        """
-        user = require_user(request)
-        scope = gate_write(request)
-        try:
-            workflow = store.get_workflow(req.workflow_id, workspace_id=scope)
-        except FileNotFoundError as exc:
-            raise HTTPException(
-                status_code=404, detail=f"Automation not found: {req.workflow_id}"
-            ) from exc
-        if not is_automation_workflow(workflow):
-            raise HTTPException(
-                status_code=404,
-                detail=f"Workflow is not an installed automation: {req.workflow_id}",
-            )
-
-        if req.dry_run:
-            report = dry_run_report(workflow)
-            last_execution = build_last_execution(
-                mode="dry_run",
-                status=report["status"],
-                summary=report["summary"],
-            )
-            _stamp_last_execution(req.workflow_id, last_execution, scope)
-            append_audit_event(
-                "automation_run_now",
-                user_email=user,
-                workflow_id=req.workflow_id,
-                dry_run=True,
-                status=report["status"],
-            )
-            return {
-                "workflow_id": req.workflow_id,
-                "dry_run": True,
-                "status": report["status"],
-                "report": report,
-                "last_execution": last_execution,
-            }
-
-        if run_executor is None:
-            raise HTTPException(
-                status_code=503,
-                detail="Automation execution runtime is not available.",
-            )
-        started = await run_executor.start_workflow(
-            workflow,
-            workflow_id=req.workflow_id,
-            user_email=user or None,
-            scope=scope,
-            inputs={"trigger": "run_now"},
-        )
-        run_id = str(((started or {}).get("run") or {}).get("id") or "")
-
-        # Bounded, non-cancelling wait: poll the durable run row so a slow
-        # execution keeps running in the background instead of being aborted.
-        run = (started or {}).get("run") or {}
-        deadline = time.monotonic() + _run_now_wait_seconds()
-        while time.monotonic() < deadline:
-            try:
-                run = store.get_workflow_run(run_id, workspace_id=scope)
-            except FileNotFoundError:
-                break
-            if str(run.get("status") or "") in RUN_TERMINAL_STATUSES:
-                break
-            await asyncio.sleep(0.05)
-
-        status = str(run.get("status") or "running")
-        completed = status in RUN_TERMINAL_STATUSES
-        summary = (
-            summarize_workflow_run(run)
-            if completed
-            else "started — still running in the background"
-        )
-        last_execution = build_last_execution(
-            mode="live",
-            status=status if completed else "running",
-            summary=summary,
-            run_id=run_id or None,
-        )
-        _stamp_last_execution(req.workflow_id, last_execution, scope)
-
-        review_item = None
-        if status == "failed":
-            review_item = enqueue_failed_execution(
-                review_queue,
-                workflow=workflow,
-                run_id=run_id or None,
-                error=summary,
-                user_email=user or None,
-                workspace_id=scope,
-            )
-        append_audit_event(
-            "automation_run_now",
-            user_email=user,
-            workflow_id=req.workflow_id,
-            dry_run=False,
-            run_id=run_id or None,
-            status=last_execution["status"],
-        )
-        payload = {
-            "workflow_id": req.workflow_id,
-            "dry_run": False,
-            "status": last_execution["status"],
-            "run_id": run_id or None,
-            "last_execution": last_execution,
-        }
-        if review_item is not None:
-            payload["review_item_id"] = review_item.get("id")
-        return payload
-
-    def _combined_runs(request: Request, limit: int = 20) -> dict[str, Any]:
-        require_user(request)
-        scope = gate_read(request)
-        capped = max(1, min(int(limit or 20), 100))
-        if hasattr(store, "list_combined_runs"):
-            payload = store.list_combined_runs(limit=capped, workspace_id=scope)
-            return _with_run_truncation_meta(payload, capped=capped)
-        # Store without the helper: merge the two existing listings in place.
-        agent_listing = (
-            store.list_agents(workspace_id=scope)
-            if hasattr(store, "list_agents")
-            else {"runs": []}
-        )
-        # Pull a wide window so agent+workflow merge can still fill ``capped``
-        # after sort; true total is the unscoped merge size before slice.
-        workflow_listing = (
-            store.list_workflow_runs(limit=max(capped, 100), workspace_id=scope)
-            if hasattr(store, "list_workflow_runs")
-            else {"runs": []}
-        )
-        from latticeai.core.workspace_runs import WorkspaceRuns
-
-        rows = []
-        for run in agent_listing.get("runs") or []:
-            rows.append(
-                _ensure_activity_run_source(
-                    WorkspaceRuns.activity_run_row(run, source="agent")
-                )
-            )
-        for run in workflow_listing.get("runs") or []:
-            rows.append(
-                _ensure_activity_run_source(
-                    WorkspaceRuns.activity_run_row(run, source="workflow")
-                )
-            )
-        rows.sort(key=lambda row: str(row.get("started_at") or ""), reverse=True)
-        total = len(rows)
-        return {
-            "runs": rows[:capped],
-            "total": total,
-            "truncated": total > capped,
-        }
-
-    @router.get("/api/activity/runs")
-    async def activity_runs(request: Request, limit: int = 20):
-        """Unified agent + workflow run timeline (layout rebuild screen 09)."""
-        return _combined_runs(request, limit=limit)
-
-    @router.get("/automations/runs/combined")
-    async def automations_runs_combined(request: Request, limit: int = 20):
-        """Alias used by the frontend handoff for the same combined timeline."""
-        return _combined_runs(request, limit=limit)
-
-    return router
-
-
-__all__ = ["create_automation_intelligence_router"]

package/latticeai/api/brain_intelligence.py

@@ -1,199 +0,0 @@
-"""Proactive Brain Intelligence API router (v9.3.0).
-
-Exposes :class:`~latticeai.services.brain_intelligence.BrainIntelligenceService`:
-health diagnosis, proactive insights, contradiction surfacing, and consent-first
-consolidation. Read endpoints use the workspace read gate; consolidation with
-``apply=true`` is a write and is audited.
-"""
-
-from __future__ import annotations
-
-from typing import Callable, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-from latticeai.services.brain_intelligence import BrainIntelligenceService
-
-
-class ResolveContradictionRequest(BaseModel):
-    """Settle one contradiction proposal (v11.1.0).
-
-    ``item_id`` is a Review Center item raised by synthesis; ``resolution`` is
-    one of ``keep_old`` / ``replace`` / ``keep_both_temporal``. Approval and
-    the temporal stamping happen together — there is no way to stamp the graph
-    without approving the proposal first.
-    """
-
-    item_id: str
-    resolution: str = "keep_both_temporal"
-
-
-class ConsolidateRequest(BaseModel):
-    apply: bool = False
-    # v9.6.x additive alias: dry_run=true means apply=false. When provided it
-    # takes precedence over ``apply`` (explicit intent wins); omitted keeps the
-    # v9.3.0 contract unchanged. Default behaviour is always a dry run.
-    dry_run: Optional[bool] = None
-
-    def effective_apply(self) -> bool:
-        if self.dry_run is not None:
-            return not self.dry_run
-        return self.apply
-
-
-def create_brain_intelligence_router(
-    *,
-    service: BrainIntelligenceService,
-    require_user: Callable[[Request], str],
-    gate_read: Callable[[Request], Optional[str]],
-    gate_write: Callable[[Request], Optional[str]],
-    append_audit_event: Callable[..., None],
-) -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/api/brain/health")
-    async def brain_health(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.health_report(user_email=user, workspace_id=scope)
-
-    @router.get("/api/brain/insights")
-    async def brain_insights(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.insights(user_email=user, workspace_id=scope)
-
-    @router.get("/api/brain/contradictions")
-    async def brain_contradictions(request: Request):
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.contradictions(user_email=user, workspace_id=scope)
-
-    @router.get("/api/brain/garden")
-    async def brain_garden(request: Request, limit: int = 8):
-        """Knowledge garden overview (v9.9.7): recent / contradictions /
-        stale / frequent, read-only and workspace-scoped."""
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.garden_overview(user_email=user, workspace_id=scope, limit=limit)
-
-    @router.get("/api/brain/vector-freshness")
-    async def brain_vector_freshness(request: Request):
-        """Vector index freshness summary (read-only, never raises).
-
-        Fixed contract consumed by the frontend:
-        ``{"status": "ready"|"pending"|"unavailable", "pending_items": int,
-        "total_items": int, "detail": str}``.
-
-        Additive since v11.2.0: ``breakdown`` splits the backlog into
-        ``embedded``/``missing``/``stale``/``queued`` when the store can. The
-        four keys above are unchanged, so existing readers see no difference.
-        """
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.vector_freshness(user_email=user, workspace_id=scope)
-
-    @router.get("/api/brain/duplicates")
-    async def brain_duplicates(request: Request):
-        """Graph-layer duplicate node candidates (read-only)."""
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.graph_duplicates(user_email=user, workspace_id=scope)
-
-    @router.get("/api/brain/quality-report")
-    async def brain_quality_report(request: Request):
-        """Combined graph quality report: duplicates, contradictions, stale
-        nodes, edge quality (read-only)."""
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.quality_report(user_email=user, workspace_id=scope)
-
-    @router.get("/api/brain/proactive-brief")
-    async def brain_proactive_brief(request: Request):
-        """Brain Brief proactive section (v11.1.0): what the Brain noticed.
-
-        Read-only — it reports the proposals already waiting in the Review
-        Center and never raises new ones.
-        """
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.proactive_brief(user_email=user, workspace_id=scope)
-
-    @router.get("/api/brain/importance")
-    async def brain_importance(request: Request):
-        """Importance + decay report (read-only): what has gone quiet."""
-        user = require_user(request)
-        scope = gate_read(request)
-        return service.importance_report(user_email=user, workspace_id=scope)
-
-    @router.post("/api/brain/synthesize")
-    async def brain_synthesize(request: Request):
-        """Run one synthesis pass. Output is review proposals, never writes."""
-        user = require_user(request)
-        scope = gate_write(request)
-        result = service.synthesize(user_email=user, workspace_id=scope)
-        append_audit_event(
-            "brain_synthesize",
-            user_email=user,
-            proposed=result.get("proposed_total", 0),
-            suppressed=result.get("suppressed", 0),
-        )
-        return result
-
-    @router.post("/api/brain/contradictions/propose")
-    async def brain_propose_contradictions(request: Request):
-        """Raise a review proposal for each contradicting pair of memories."""
-        user = require_user(request)
-        scope = gate_write(request)
-        result = service.propose_contradictions(user_email=user, workspace_id=scope)
-        append_audit_event(
-            "brain_contradiction_proposals",
-            user_email=user,
-            proposed=result.get("proposed_count", 0),
-            suppressed=result.get("suppressed", 0),
-        )
-        return result
-
-    @router.post("/api/brain/contradictions/resolve")
-    async def brain_resolve_contradiction(
-        req: ResolveContradictionRequest, request: Request
-    ):
-        """Approve a contradiction proposal and stamp the graph accordingly."""
-        user = require_user(request)
-        scope = gate_write(request)
-        try:
-            result = service.resolve_contradiction(
-                req.item_id, resolution=req.resolution, workspace_id=scope
-            )
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-        except FileNotFoundError:
-            raise HTTPException(status_code=404, detail=req.item_id)
-        append_audit_event(
-            "brain_contradiction_resolved",
-            user_email=user,
-            item_id=req.item_id,
-            resolution=req.resolution,
-        )
-        return result
-
-    @router.post("/api/brain/consolidate")
-    async def brain_consolidate(req: ConsolidateRequest, request: Request):
-        user = require_user(request)
-        apply = req.effective_apply()
-        scope = gate_write(request) if apply else gate_read(request)
-        result = service.consolidate(apply=apply, user_email=user, workspace_id=scope)
-        append_audit_event(
-            "brain_consolidate",
-            user_email=user,
-            mode=result.get("mode"),
-            duplicate_memories=result.get("duplicate_memory_count", 0),
-            pruned=result.get("pruned", 0),
-        )
-        return result
-
-    return router
-
-
-__all__ = ["create_brain_intelligence_router"]