ltcai 9.9.2 → 9.9.4

package/latticeai/api/setup.py

@@ -17,7 +17,15 @@ from latticeai.setup.auto_setup import (
     verify as auto_setup_verify,
 )
 from latticeai.models.router import parse_model_ref
+from latticeai.setup.demo_corpus import (
+    DEMO_DOCUMENTS,
+    DEMO_METADATA_FLAG,
+    DEMO_URI_PREFIX,
+    demo_source_uri,
+    suggested_questions,
+)
 from latticeai.setup.wizard import get_recommendations, install_stream, open_url, scan_environment
+from lattice_brain.ingestion import IngestionItem
 
 
 class SetupInstallRequest(BaseModel):
@@ -25,7 +33,18 @@ class SetupInstallRequest(BaseModel):
     confirmation_token: Optional[str] = None
 
 
-def create_setup_router(*, model_router, require_user) -> APIRouter:
+class DemoCorpusRequest(BaseModel):
+    workspace_id: Optional[str] = None
+
+
+def create_setup_router(
+    *,
+    model_router,
+    require_user,
+    ingestion_pipeline=None,
+    knowledge_graph=None,
+    workspace_service=None,
+) -> APIRouter:
     api_router = APIRouter()
     router = model_router
 
@@ -157,6 +176,120 @@ def create_setup_router(*, model_router, require_user) -> APIRouter:
         return {"status": "ok", "opened": url, "mcp_id": mcp_id}
     
     
+    # ── First Value Loop demo corpus (backlog #3, review §3.3 P0) ────────────
+
+    def _require_demo_pipeline():
+        if ingestion_pipeline is None or not ingestion_pipeline.available():
+            raise HTTPException(
+                status_code=503, detail="Knowledge Graph ingestion is disabled.",
+            )
+        if knowledge_graph is None:
+            raise HTTPException(status_code=503, detail="Knowledge Graph is disabled.")
+
+    def _demo_workspace(request: Request, body_workspace: Optional[str], user: str) -> Optional[str]:
+        header = request.headers.get("X-Workspace-Id")
+        header = header.strip() if header and header.strip() else None
+        supplied = [value for value in (body_workspace, header) if value]
+        if len(set(supplied)) > 1:
+            raise HTTPException(status_code=403, detail="Workspace selectors must match.")
+        requested = supplied[0] if supplied else None
+        if workspace_service is None:
+            return requested
+        try:
+            return workspace_service.resolve_write_scope(requested, user or None)
+        except PermissionError as exc:
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
+
+    @api_router.get("/api/setup/demo-corpus")
+    async def demo_corpus_status(request: Request):
+        """Whether the demo corpus is installed + the suggestion chips."""
+        require_user(request)
+        _require_demo_pipeline()
+        installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
+        return {
+            "installed": bool(installed),
+            "documents": installed,
+            "document_count": len(installed),
+            "suggested_questions": suggested_questions(),
+        }
+
+    @api_router.post("/api/setup/demo-corpus")
+    async def demo_corpus_install(request: Request, req: Optional[DemoCorpusRequest] = None):
+        """One-click ingest of the 3 built-in demo documents (idempotent).
+
+        Every document goes through the normal IngestionPipeline door with
+        ``demo://`` provenance so it is honest (real nodes, real chunks, real
+        provenance) and removable via DELETE. Re-POSTing reports duplicates
+        instead of duplicating.
+        """
+        user = require_user(request)
+        _require_demo_pipeline()
+        workspace_id = _demo_workspace(request, req.workspace_id if req else None, user)
+        results = []
+        ingested = 0
+        duplicates = 0
+        failed = 0
+        for doc in DEMO_DOCUMENTS:
+            result = ingestion_pipeline.ingest(
+                IngestionItem(
+                    source_type="note",
+                    title=doc["title"],
+                    text=doc["text"],
+                    source_uri=demo_source_uri(doc["id"]),
+                    owner=user or None,
+                    workspace_id=workspace_id,
+                    metadata={DEMO_METADATA_FLAG: True, "demo_id": doc["id"]},
+                ),
+                user_email=user or None,
+            )
+            if result.status != "ok":
+                failed += 1
+            elif result.duplicate:
+                duplicates += 1
+            else:
+                ingested += 1
+            results.append({
+                "demo_id": doc["id"],
+                "title": doc["title"],
+                "source_uri": demo_source_uri(doc["id"]),
+                "status": result.status,
+                "node_id": result.node_id,
+                "duplicate": result.duplicate,
+                "chunk_count": result.chunk_count,
+                "detail": result.detail,
+            })
+        status = "ok" if failed == 0 else ("partial" if (ingested + duplicates) else "failed")
+        return {
+            "status": status,
+            "ingested": ingested,
+            "duplicates": duplicates,
+            "failed": failed,
+            "documents": results,
+            "suggested_questions": suggested_questions(),
+        }
+
+    @api_router.delete("/api/setup/demo-corpus")
+    async def demo_corpus_remove(request: Request):
+        """Remove every demo document (node + chunks + edges + orphan source)."""
+        require_user(request)
+        _require_demo_pipeline()
+        installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
+        removed = []
+        for doc in installed:
+            outcome = knowledge_graph.delete_document_tree(doc["id"])
+            removed.append({
+                "node_id": doc["id"],
+                "title": doc.get("title"),
+                "source_uri": doc.get("source_uri"),
+                "status": outcome.get("status"),
+                "removed_nodes": outcome.get("removed_nodes", 0),
+            })
+        return {
+            "status": "ok",
+            "removed_count": len(removed),
+            "removed": removed,
+        }
+
     @api_router.post("/permissions/open/{permission_id}")
     async def open_permission_settings(permission_id: str, request: Request):
         require_user(request)

package/latticeai/api/tools.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, File, HTTPException, Request, UploadFile
-from fastapi.responses import FileResponse
+from fastapi.responses import FileResponse, Response
 from pydantic import BaseModel
 
 from latticeai.api.computer_use import create_computer_use_router
@@ -543,8 +543,38 @@ def create_tools_router(
             filename=target.name,
             media_type="application/octet-stream",
         )
-    
-    
+
+
+    @api_router.get("/tools/download_zip")
+    async def tools_download_zip(path: str, request: Request):
+        """Serve a generated project directory from the agent workspace as a zip.
+
+        The multi-file artifact loop writes bundles like ``todo-app/`` —
+        this is their one-click download. Path confinement mirrors
+        ``/tools/download``: anything outside the workspace is refused.
+        """
+        require_user(request)
+        from urllib.parse import unquote
+
+        from latticeai.tools.filesystem import zip_workspace_dir
+
+        rel = unquote(path).lstrip("/")
+        target = (AGENT_ROOT / rel).resolve()
+        if AGENT_ROOT not in target.parents and target != AGENT_ROOT:
+            raise HTTPException(status_code=403, detail="경로가 작업 공간 밖입니다.")
+        if not target.exists() or not target.is_dir():
+            raise HTTPException(status_code=404, detail="디렉터리가 없습니다.")
+        try:
+            payload, filename = zip_workspace_dir(rel)
+        except ToolError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return Response(
+            content=payload,
+            media_type="application/zip",
+            headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+        )
+
+
     @api_router.post("/upload/document")
     async def upload_document(request: Request, file: UploadFile = File(...)):
         current_user = require_user(request)

package/latticeai/app_factory.py

@@ -395,6 +395,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     INGESTION_PIPELINE = _persistence_runtime["INGESTION_PIPELINE"]
     DEVICE_IDENTITY = _persistence_runtime["DEVICE_IDENTITY"]
     KG_PORTABILITY = _persistence_runtime["KG_PORTABILITY"]
+    FUNNEL_METRICS = _persistence_runtime["FUNNEL_METRICS"]
 
     def _require_graph():
         if not ENABLE_GRAPH or KNOWLEDGE_GRAPH is None:
@@ -951,6 +952,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         public_model=PUBLIC_MODEL,
         local_model=LOCAL_MODEL or "",
         on_chat_message=on_chat_message,
+        funnel_metrics=FUNNEL_METRICS,
     )
     app.state.context = context
 
@@ -1036,6 +1038,17 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             gate_write=PLATFORM.gate_write,
             append_audit_event=append_audit_event,
             workspace_graph=_workspace_graph,
+            run_executor=RUN_EXECUTOR,
+            review_queue=REVIEW_QUEUE,
+        )
+    )
+    # UX funnel metrics (backlog #16): admin-only runtime counters.
+    from latticeai.api.funnel_metrics import create_funnel_metrics_router
+
+    app.include_router(
+        create_funnel_metrics_router(
+            service=FUNNEL_METRICS,
+            require_admin=require_admin,
         )
     )
     COMMAND_CENTER = CommandCenterService(
@@ -1212,6 +1225,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         gardener=gardener,
         create_setup_router=create_setup_router,
         model_router=router,
+        knowledge_graph=KNOWLEDGE_GRAPH,
     )
 
     # ── Entry Point ────────────────────────────────────────────────────────────────