keboola-cli 0.63.4__py3-none-any.whl

keboola_agent_cli/server/routers/ai_chat.py

@@ -0,0 +1,129 @@
+"""Local AI chat endpoint (#300).
+
+Backs the dashboard's Local AI tile -- a generic chat surface that spawns
+the user's local ``claude`` / ``codex`` / ``gemini`` CLI with a meta-prompt
+telling it "you are an AI co-pilot for kbagent; run `kbagent context`
+first if you need command docs, then answer the user's question."
+
+Distinct from:
+
+- ``/agents/prompt/improve/stream`` -- rewrites a draft prompt into a
+  polished single-shot prompt body.
+- ``/workspaces/sql/improve/stream`` -- writes SQL grounded in a specific
+  workspace context.
+
+This endpoint is the freeform variant -- no output shape constraint, no
+single-task framing. Used by the dashboard Local AI chat that replaces
+the Kai tile for projects without a master Storage token (#291 wontfix
+rationale).
+
+Same SSE wire format as the other helpers (init / stdout / stderr /
+done events) so the React side can reuse the streaming progress renderer.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from ...constants import AI_CHAT_HELPER_TIMEOUT
+from ..dependencies import ServiceRegistry, get_registry
+
+router = APIRouter(prefix="/ai", tags=["ai-chat"])
+
+
+class AiChatRequest(BaseModel):
+    """Input for the /ai/chat/stream endpoint.
+
+    Single-shot: each request is independent. Conversation history is kept
+    on the React side as scrollback; it is NOT forwarded to the AI on the
+    next message (yet). Multi-turn with persisted history is tracked as
+    a follow-up feature.
+    """
+
+    cli: str  # claude | codex | gemini -- same recipe as ai_agent runs
+    message: str
+    project: str | None = None
+    branch_id: int | None = None
+    extra_args: list[str] = []
+
+
+def _sse(event: str, data: dict[str, Any]) -> bytes:
+    """Encode a single SSE frame (event + data)."""
+    return f"event: {event}\ndata: {json.dumps(data, default=str)}\n\n".encode()
+
+
+@router.post("/chat/stream", summary="Stream a local AI chat response")
+async def chat_stream(
+    body: AiChatRequest,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> StreamingResponse:
+    """Stream a local-AI chat response back to the dashboard.
+
+    Build a generic chat meta-prompt grounded in the user's active
+    project / branch, hand it to the chosen CLI via
+    ``stream_ai_agent_events``, and forward the SSE events through to
+    the client. The final ``done`` event mirrors the shape used by
+    other helpers; the React side renders the assistant's text +
+    tool_use activity log in real time.
+    """
+    from ..agent_runner import (
+        build_local_ai_meta_prompt,
+        stream_ai_agent_events,
+    )
+
+    message = body.message.strip()
+    if not message:
+        raise HTTPException(status_code=400, detail="message must not be empty")
+
+    meta_prompt = build_local_ai_meta_prompt(
+        message=message,
+        project=body.project,
+        branch_id=body.branch_id,
+        serve_url=getattr(registry, "serve_url", None),
+    )
+    params: dict[str, Any] = {
+        "cli": body.cli,
+        "prompt": meta_prompt,
+        "extra_args": body.extra_args,
+        "timeout": AI_CHAT_HELPER_TIMEOUT,
+    }
+
+    async def gen() -> AsyncIterator[bytes]:
+        yield _sse(
+            "init",
+            {
+                "kind": "local_ai_chat",
+                "cli": body.cli,
+                "project": body.project,
+                "branch_id": body.branch_id,
+                # Surface the full meta-prompt so the UI can offer a
+                # "Show prompt" transparency panel identical to the SQL
+                # helper's. Debugging is impossible without it.
+                "meta_prompt": meta_prompt,
+                "message_preview": message[:200],
+            },
+        )
+        try:
+            async for evt in stream_ai_agent_events(registry, params):
+                yield _sse(evt["event"], evt["data"])
+        except Exception as exc:
+            # Catch-all: both ValueError (bad CLI / empty prompt) and any
+            # unexpected error need to terminate the SSE stream with a
+            # final ``done`` event so the React side doesn't hang on an
+            # unterminated stream. Body shape is identical in both cases.
+            yield _sse("done", {"status": "error", "error": str(exc)})
+
+    return StreamingResponse(
+        gen(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache, no-transform",
+            "X-Accel-Buffering": "no",
+        },
+    )

keboola_agent_cli/server/routers/branches.py

@@ -0,0 +1,133 @@
+"""Branch lifecycle and metadata endpoints."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, Query
+from pydantic import BaseModel
+
+from ..dependencies import ServiceRegistry, get_registry
+
+router = APIRouter(prefix="/branches", tags=["branches"])
+
+
+class BranchCreate(BaseModel):
+    name: str
+    description: str = ""
+
+
+class BranchUse(BaseModel):
+    branch_id: int
+
+
+class MetadataSet(BaseModel):
+    value: str
+
+
+@router.get("", summary="List branches")
+def list_branches(
+    project: list[str] | None = Query(None),
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """List development branches across one or more projects. Mirrors `kbagent branch list`."""
+    return registry.branch.list_branches(aliases=project)
+
+
+@router.post("/{project}", summary="Create a branch")
+def create(
+    project: str, body: BranchCreate, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Create a new development branch. Mirrors `kbagent branch create`."""
+    return registry.branch.create_branch(
+        alias=project, name=body.name, description=body.description
+    )
+
+
+@router.post("/{project}/use", summary="Pin the active branch")
+def use(
+    project: str, body: BranchUse, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Set the active branch for the project. Mirrors `kbagent branch use`."""
+    return registry.branch.set_active_branch(alias=project, branch_id=body.branch_id)
+
+
+@router.post("/{project}/reset", summary="Reset to the default branch")
+def reset(project: str, registry: ServiceRegistry = Depends(get_registry)) -> dict[str, Any]:
+    """Clear branch pin and revert to default branch. Mirrors `kbagent branch reset`."""
+    return registry.branch.reset_branch(alias=project)
+
+
+@router.delete("/{project}/{branch_id}", summary="Delete a branch")
+def delete(
+    project: str, branch_id: int, registry: ServiceRegistry = Depends(get_registry)
+) -> dict[str, Any]:
+    """Delete a development branch. Mirrors `kbagent branch delete`."""
+    return registry.branch.delete_branch(alias=project, branch_id=branch_id)
+
+
+@router.get("/{project}/merge-url", summary="Get the branch merge URL")
+def merge_url(
+    project: str,
+    branch_id: int | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """UI URL for merging a branch into main. Mirrors `kbagent branch merge`."""
+    return registry.branch.get_merge_url(alias=project, branch_id=branch_id)
+
+
+@router.get("/{project}/metadata", summary="List branch metadata")
+def metadata_list(
+    project: str,
+    branch_id: int | str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """List all metadata keys for a branch. Mirrors `kbagent branch metadata-list`."""
+    return registry.branch.list_branch_metadata(
+        alias=project, branch_id=branch_id if branch_id is not None else "default"
+    )
+
+
+@router.get("/{project}/metadata/{key}", summary="Get a branch metadata value")
+def metadata_get(
+    project: str,
+    key: str,
+    branch_id: int | str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Fetch a single branch metadata entry. Mirrors `kbagent branch metadata-get`."""
+    return registry.branch.get_branch_metadata(
+        alias=project, key=key, branch_id=branch_id if branch_id is not None else "default"
+    )
+
+
+@router.put("/{project}/metadata/{key}", summary="Set a branch metadata value")
+def metadata_set(
+    project: str,
+    key: str,
+    body: MetadataSet,
+    branch_id: int | str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Write a branch metadata entry. Mirrors `kbagent branch metadata-set`."""
+    return registry.branch.set_branch_metadata(
+        alias=project,
+        key=key,
+        value=body.value,
+        branch_id=branch_id if branch_id is not None else "default",
+    )
+
+
+@router.delete("/{project}/metadata/{metadata_id}", summary="Delete a branch metadata entry")
+def metadata_delete(
+    project: str,
+    metadata_id: int,
+    branch_id: int | str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Remove a branch metadata entry by id. Mirrors `kbagent branch metadata-delete`."""
+    return registry.branch.delete_branch_metadata(
+        alias=project,
+        metadata_id=metadata_id,
+        branch_id=branch_id if branch_id is not None else "default",
+    )

keboola_agent_cli/server/routers/components.py

@@ -0,0 +1,48 @@
+"""Component discovery (list/detail/scaffold)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends
+
+from ..dependencies import ServiceRegistry, get_registry
+
+router = APIRouter(prefix="/components", tags=["components"])
+
+
+@router.get("", summary="List components")
+def list_components(
+    project: str | None = None,
+    type: str | None = None,
+    query: str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Browse available components, optionally filtered. Mirrors `kbagent component list`."""
+    aliases = [project] if project else None
+    return registry.component.list_components(aliases=aliases, component_type=type, query=query)
+
+
+@router.get("/{component_id}", summary="Get component detail")
+def detail(
+    component_id: str,
+    project: str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Full component metadata including config schema. Mirrors `kbagent component detail`."""
+    if project is None:
+        project, _ = registry.project.resolve_pinned_alias(None)
+    return registry.component.get_component_detail(alias=project, component_id=component_id)
+
+
+@router.post("/{component_id}/scaffold", summary="Scaffold a new component config")
+def scaffold(
+    component_id: str,
+    project: str | None = None,
+    name: str | None = None,
+    registry: ServiceRegistry = Depends(get_registry),
+) -> dict[str, Any]:
+    """Generate a starter configuration for the component. Mirrors `kbagent config new`."""
+    if project is None:
+        project, _ = registry.project.resolve_pinned_alias(None)
+    return registry.component.generate_scaffold(alias=project, component_id=component_id, name=name)