flowent 0.0.6 → 0.0.10

package/backend/src/flowent/main.py

@@ -1,25 +1,76 @@
-from __future__ import annotations
-
-import asyncio
+import json
+import logging
 import os
-from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator
 from pathlib import Path
+from typing import Literal
+from uuid import uuid4
 
-from fastapi import FastAPI
-from fastapi.responses import FileResponse
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse, StreamingResponse
 from fastapi.staticfiles import StaticFiles
-from starlette.middleware.sessions import SessionMiddleware
+from pydantic import BaseModel, ConfigDict
+
+from flowent.agent import run_agent_stream
+from flowent.context import runtime_context_messages
+from flowent.llm import (
+    ChatMessage,
+    CompletionCallable,
+    ProviderConnection,
+    ProviderFormat,
+    complete_chat,
+    list_provider_models,
+)
+from flowent.logging import TRACE_LEVEL, ensure_logging_configured
+from flowent.storage import (
+    StateStore,
+    StoredMessage,
+    StoredProvider,
+    StoredSettings,
+    StoredState,
+    StoredToolItem,
+)
 
-from flowent.access import AccessControlMiddleware
-from flowent.config import Config
-from flowent.events import event_bus
-from flowent.logging import setup_logging
-from flowent.runtime import bootstrap_runtime, shutdown_runtime
+logger = logging.getLogger("flowent.main")
 
-config = Config()
-setup_logging(config)
 
 DEFAULT_STATIC_DIR = Path(__file__).parent / "static"
+COMPACTED_CONTEXT_MARKER = "Context compacted"
+COMPACT_SYSTEM_PROMPT = "You are compacting Flowent workspace context."
+
+
+class ProviderModelsRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    provider: ProviderFormat
+    secret_reference: str
+    base_url: str | None = None
+
+
+class ProviderModelsResponse(BaseModel):
+    models: list[str]
+
+
+class WorkspaceMessagesRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    messages: list[StoredMessage]
+
+
+class WorkspaceRespondRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    content: str
+
+
+class WorkspaceCompactResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    message: StoredMessage
+
+
+def stream_event(event: str, data: dict[str, object]) -> str:
+    return f"event: {event}\ndata: {json.dumps(data)}\n\n"
 
 
 def frontend_static_directory() -> Path:
@@ -32,78 +83,278 @@ def frontend_static_directory() -> Path:
     return DEFAULT_STATIC_DIR
 
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    from flowent.access import (
-        initialize_live_access_signature,
-        refresh_live_access_signature,
+def selected_connection(state: StoredState) -> ProviderConnection:
+    provider = next(
+        (
+            stored_provider
+            for stored_provider in state.providers
+            if stored_provider.id == state.settings.selected_provider_id
+        ),
+        None,
     )
+    if provider is None or not state.settings.selected_model:
+        logger.warning("Workspace request blocked because provider or model is missing")
+        raise HTTPException(
+            status_code=400,
+            detail="Choose a provider and model before sending.",
+        )
+    if not provider.api_key:
+        logger.warning("Workspace request blocked because selected provider has no key")
+        raise HTTPException(status_code=400, detail="Add a key before sending.")
 
-    loop = asyncio.get_running_loop()
-    event_bus.set_loop(loop)
-
-    bootstrap_runtime()
-    initialize_live_access_signature()
+    logger.debug(
+        "Workspace request using provider=%s model=%s",
+        provider.name,
+        state.settings.selected_model,
+    )
+    return ProviderConnection(
+        base_url=provider.base_url or None,
+        model=state.settings.selected_model,
+        name=provider.name,
+        provider=provider.type,
+        secret_reference=provider.api_key,
+    )
 
-    stop_event = asyncio.Event()
 
-    async def watch_access_state() -> None:
-        while True:
-            try:
-                await asyncio.wait_for(stop_event.wait(), timeout=1.0)
-                return
-            except TimeoutError:
-                if refresh_live_access_signature():
-                    await event_bus.close_all(
-                        code=4001, reason="Access session updated"
-                    )
+def latest_compacted_context_index(messages: list[StoredMessage]) -> int | None:
+    for index in range(len(messages) - 1, -1, -1):
+        message = messages[index]
+        if message.author == "system" and message.content == COMPACTED_CONTEXT_MARKER:
+            return index
+    return None
 
-    access_watch_task = asyncio.create_task(watch_access_state())
 
-    yield
+def workspace_chat_messages(
+    messages: list[StoredMessage],
+    compacted_context: str = "",
+) -> list[ChatMessage]:
+    chat_messages: list[ChatMessage] = []
+    marker_index = latest_compacted_context_index(messages)
+    visible_messages = messages
 
-    stop_event.set()
-    await access_watch_task
-    shutdown_runtime()
+    if compacted_context and marker_index is not None:
+        chat_messages.extend(
+            [
+                ChatMessage(role="user", content=COMPACTED_CONTEXT_MARKER),
+                ChatMessage(role="assistant", content=compacted_context),
+            ]
+        )
+        visible_messages = messages[marker_index + 1 :]
 
+    for message in visible_messages:
+        if message.author == "system" and message.content == COMPACTED_CONTEXT_MARKER:
+            continue
+        if message.author not in ("user", "assistant"):
+            raise HTTPException(status_code=400, detail="Message history is invalid.")
+        role: Literal["user", "assistant"] = (
+            "user" if message.author == "user" else "assistant"
+        )
+        chat_messages.append(ChatMessage(role=role, content=message.content))
+    return chat_messages
 
-def create_app(*, serve_frontend: bool = True) -> FastAPI:
-    from flowent.access import ensure_session_signing_secret
-    from flowent.settings import get_settings, save_settings
 
-    settings = get_settings()
-    if ensure_session_signing_secret(settings):
-        save_settings(settings)
-    session_secret = (
-        config.SESSION_SECRET.strip() or settings.access.session_signing_secret
+def compact_prompt_messages(
+    messages: list[StoredMessage],
+    compacted_context: str,
+    runtime_messages: list[ChatMessage] | None = None,
+) -> list[ChatMessage]:
+    history_messages = [
+        *(runtime_messages or []),
+        *workspace_chat_messages(messages, compacted_context),
+    ]
+    history = "\n\n".join(
+        f"{message.role}: {message.content}" for message in history_messages
     )
+    return [
+        ChatMessage(role="system", content=COMPACT_SYSTEM_PROMPT),
+        ChatMessage(
+            role="user",
+            content=(
+                "Compact the current Flowent workspace context for the next turn.\n\n"
+                "Keep the details needed to continue accurately, including decisions, "
+                "constraints, pending work, and referenced facts.\n\n"
+                f"Conversation:\n{history}"
+            ),
+        ),
+    ]
 
-    app = FastAPI(
-        title=config.APP_NAME,
-        debug=config.DEBUG,
-        lifespan=lifespan,
-    )
-    app.add_middleware(AccessControlMiddleware)
-    app.add_middleware(
-        SessionMiddleware,
-        secret_key=session_secret,
-        session_cookie=config.SESSION_COOKIE_NAME,
-        max_age=config.SESSION_MAX_AGE_SECONDS,
-        same_site="lax",
-        https_only=False,
-    )
 
-    from flowent.routes import router
+def create_app(
+    *,
+    serve_frontend: bool = True,
+    chat_completion: CompletionCallable | None = None,
+) -> FastAPI:
+    ensure_logging_configured()
+
+    app = FastAPI(title="Flowent")
+    store = StateStore()
 
-    app.include_router(router)
     static_dir = frontend_static_directory().resolve(strict=False)
+    logger.debug("Flowent app created serve_frontend=%s", serve_frontend)
+    logger.info("Static directory: %s", static_dir)
 
-    if serve_frontend and static_dir.is_dir():
-        app.mount(
-            "/assets",
-            StaticFiles(directory=static_dir / "assets"),
-            name="assets",
+    @app.get("/api/health")
+    async def health() -> dict[str, str]:
+        return {"status": "ok"}
+
+    @app.get("/api/state")
+    async def app_state() -> StoredState:
+        return store.read_state()
+
+    @app.post("/api/providers")
+    async def save_provider(provider: StoredProvider) -> StoredProvider:
+        return store.save_provider(provider)
+
+    @app.post("/api/providers/models")
+    async def provider_models(request: ProviderModelsRequest) -> ProviderModelsResponse:
+        return ProviderModelsResponse(
+            models=list_provider_models(
+                base_url=request.base_url,
+                provider=request.provider,
+                secret_reference=request.secret_reference,
+            ),
+        )
+
+    @app.put("/api/settings")
+    async def save_settings(settings: StoredSettings) -> StoredSettings:
+        return store.save_settings(settings)
+
+    @app.put("/api/workspace/messages")
+    async def save_workspace_messages(
+        request: WorkspaceMessagesRequest,
+    ) -> WorkspaceMessagesRequest:
+        return WorkspaceMessagesRequest(messages=store.save_messages(request.messages))
+
+    @app.post("/api/workspace/compact")
+    async def compact_workspace() -> WorkspaceCompactResponse:
+        logger.info("Workspace compact requested")
+        state = store.read_state()
+        connection = selected_connection(state)
+        compacted_context = store.read_compacted_context()
+        cwd = Path.cwd()
+
+        try:
+            summary = await complete_chat(
+                connection,
+                compact_prompt_messages(
+                    state.messages,
+                    compacted_context,
+                    runtime_context_messages(cwd),
+                ),
+                completion=chat_completion,
+            )
+        except HTTPException:
+            raise
+        except Exception as error:
+            logger.exception("Workspace compact failed")
+            raise HTTPException(
+                status_code=500,
+                detail="Context could not be compacted.",
+            ) from error
+
+        marker = StoredMessage(
+            author="system",
+            content=COMPACTED_CONTEXT_MARKER,
+            id=str(uuid4()),
+        )
+        store.save_compacted_context(summary.content)
+        store.save_messages([*state.messages, marker])
+        logger.info(
+            "Workspace compact completed summary_length=%s", len(summary.content)
         )
+        logger.log(TRACE_LEVEL, "Workspace compact summary=%r", summary.content)
+        return WorkspaceCompactResponse(message=marker)
+
+    @app.post("/api/workspace/respond")
+    async def respond_to_workspace(
+        request: WorkspaceRespondRequest,
+    ) -> StreamingResponse:
+        logger.info(
+            "Workspace response requested content_length=%s", len(request.content)
+        )
+        logger.log(TRACE_LEVEL, "Workspace user content=%r", request.content)
+        state = store.read_state()
+        connection = selected_connection(state)
+        cwd = Path.cwd()
+
+        user_message = StoredMessage(
+            author="user",
+            content=request.content,
+            id=str(uuid4()),
+        )
+        next_messages = [*state.messages, user_message]
+        store.save_messages(next_messages)
+        chat_messages = workspace_chat_messages(
+            next_messages,
+            store.read_compacted_context(),
+        )
+        request_messages = [
+            message.model_dump()
+            for message in [*runtime_context_messages(cwd), *chat_messages]
+        ]
+
+        async def response_stream() -> AsyncIterator[str]:
+            assistant_tools: dict[str, StoredToolItem] = {}
+            try:
+                async for event in run_agent_stream(
+                    completion=chat_completion,
+                    connection=connection,
+                    cwd=cwd,
+                    messages=request_messages,
+                ):
+                    if event.event == "tool_start":
+                        tool = event.data.get("tool")
+                        if isinstance(tool, dict) and isinstance(tool.get("id"), str):
+                            assistant_tools[tool["id"]] = StoredToolItem.model_validate(
+                                tool
+                            )
+                    if event.event in {"tool_done", "tool_error"}:
+                        tool_id = event.data.get("id")
+                        if isinstance(tool_id, str) and tool_id in assistant_tools:
+                            assistant_tools[tool_id] = StoredToolItem.model_validate(
+                                {
+                                    **assistant_tools[tool_id].model_dump(
+                                        exclude_none=True
+                                    ),
+                                    **event.data,
+                                }
+                            )
+                    logger.log(
+                        TRACE_LEVEL,
+                        "Workspace stream event=%s data=%r",
+                        event.event,
+                        event.data,
+                    )
+                    if event.event == "done":
+                        message = event.data.get("message")
+                        if isinstance(message, dict):
+                            next_messages.append(
+                                StoredMessage(
+                                    author="assistant",
+                                    content=str(message.get("content") or ""),
+                                    id=str(message.get("id") or uuid4()),
+                                    tools=list(assistant_tools.values()),
+                                )
+                            )
+                            store.save_messages(next_messages)
+                    yield stream_event(event.event, event.data)
+            except Exception as error:
+                logger.exception("Workspace response failed")
+                yield stream_event(
+                    "error",
+                    {"message": str(error) or "Message could not be sent."},
+                )
+                return
+
+        return StreamingResponse(
+            response_stream(),
+            media_type="text/event-stream",
+        )
+
+    if serve_frontend and static_dir.is_dir():
+        assets_dir = static_dir / "assets"
+        if assets_dir.is_dir():
+            app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
 
         @app.get("/{path:path}")
         async def spa_fallback(path: str) -> FileResponse:
@@ -121,4 +372,4 @@ app = create_app()
 if __name__ == "__main__":
     import uvicorn
 
-    uvicorn.run(app, reload=config.DEBUG)
+    uvicorn.run(app)

package/backend/src/flowent/patch.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class PatchError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class PatchChange:
+    path: Path
+    kind: str
+    move_path: Path | None = None
+
+
+def affected_paths(patch: str, cwd: Path) -> list[Path]:
+    paths: list[Path] = []
+    for line in patch.splitlines():
+        if line.startswith(
+            ("*** Add File: ", "*** Delete File: ", "*** Update File: ")
+        ):
+            paths.append((cwd / line.split(": ", 1)[1]).resolve(strict=False))
+        elif line.startswith("*** Move to: "):
+            paths.append(
+                (cwd / line.removeprefix("*** Move to: ")).resolve(strict=False)
+            )
+    return paths
+
+
+def parse_patch(patch: str, cwd: Path) -> list[dict[str, object]]:
+    lines = patch.splitlines()
+    if not lines or lines[0].strip() != "*** Begin Patch":
+        raise PatchError("Patch must start with Begin Patch.")
+    if lines[-1].strip() != "*** End Patch":
+        raise PatchError("Patch must end with End Patch.")
+
+    operations: list[dict[str, object]] = []
+    index = 1
+    while index < len(lines) - 1:
+        line = lines[index]
+        if line.startswith("*** Add File: "):
+            target = (cwd / line.removeprefix("*** Add File: ")).resolve(strict=False)
+            index += 1
+            contents: list[str] = []
+            while index < len(lines) - 1 and not lines[index].startswith("*** "):
+                content_line = lines[index]
+                if not content_line.startswith("+"):
+                    raise PatchError("Add file lines must start with +.")
+                contents.append(content_line[1:])
+                index += 1
+            operations.append(
+                {"kind": "add", "path": target, "content": "\n".join(contents) + "\n"}
+            )
+            continue
+        if line.startswith("*** Delete File: "):
+            target = (cwd / line.removeprefix("*** Delete File: ")).resolve(
+                strict=False
+            )
+            operations.append({"kind": "delete", "path": target})
+            index += 1
+            continue
+        if line.startswith("*** Update File: "):
+            target = (cwd / line.removeprefix("*** Update File: ")).resolve(
+                strict=False
+            )
+            index += 1
+            move_path = None
+            if index < len(lines) - 1 and lines[index].startswith("*** Move to: "):
+                move_path = (cwd / lines[index].removeprefix("*** Move to: ")).resolve(
+                    strict=False
+                )
+                index += 1
+            chunks: list[dict[str, list[str]]] = []
+            current: dict[str, list[str]] | None = None
+            while index < len(lines) - 1 and not lines[index].startswith("*** "):
+                content_line = lines[index]
+                if content_line.startswith("@@"):
+                    current = {"remove": [], "add": []}
+                    chunks.append(current)
+                elif content_line.startswith("-"):
+                    if current is None:
+                        current = {"remove": [], "add": []}
+                        chunks.append(current)
+                    current["remove"].append(content_line[1:])
+                elif content_line.startswith("+"):
+                    if current is None:
+                        current = {"remove": [], "add": []}
+                        chunks.append(current)
+                    current["add"].append(content_line[1:])
+                elif content_line.startswith(" ") or content_line == "*** End of File":
+                    pass
+                else:
+                    raise PatchError(
+                        "Update lines must start with context, +, -, or @@."
+                    )
+                index += 1
+            operations.append(
+                {
+                    "kind": "update",
+                    "path": target,
+                    "move_path": move_path,
+                    "chunks": chunks,
+                }
+            )
+            continue
+        if not line.strip():
+            index += 1
+            continue
+        raise PatchError(f"Invalid patch line: {line}")
+    return operations
+
+
+def apply_update(original: str, chunks: list[dict[str, list[str]]]) -> str:
+    content = original
+    for chunk in chunks:
+        remove = "\n".join(chunk["remove"])
+        add = "\n".join(chunk["add"])
+        if remove:
+            candidates = [remove, remove + "\n"]
+            for candidate in candidates:
+                if candidate in content:
+                    replacement = add + (
+                        "\n" if candidate.endswith("\n") and add else ""
+                    )
+                    content = content.replace(candidate, replacement, 1)
+                    break
+            else:
+                raise PatchError("Patch context was not found.")
+        elif add:
+            content = (
+                content
+                + ("" if content.endswith("\n") or not content else "\n")
+                + add
+                + "\n"
+            )
+    return content
+
+
+def apply_patch(patch: str, cwd: Path) -> dict[str, object]:
+    operations = parse_patch(patch, cwd)
+    changed: list[dict[str, str]] = []
+    for operation in operations:
+        kind = str(operation["kind"])
+        path = operation["path"]
+        if not isinstance(path, Path):
+            raise PatchError("Patch path is invalid.")
+        if kind == "add":
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(str(operation["content"]))
+            changed.append({"path": str(path), "status": "added"})
+        elif kind == "delete":
+            path.unlink()
+            changed.append({"path": str(path), "status": "deleted"})
+        elif kind == "update":
+            original = path.read_text()
+            chunks = operation["chunks"]
+            if not isinstance(chunks, list):
+                raise PatchError("Patch chunks are invalid.")
+            new_content = apply_update(original, chunks)
+            move_path = operation.get("move_path")
+            if isinstance(move_path, Path):
+                move_path.parent.mkdir(parents=True, exist_ok=True)
+                move_path.write_text(new_content)
+                path.unlink()
+                changed.append({"path": str(move_path), "status": "modified"})
+            else:
+                path.write_text(new_content)
+                changed.append({"path": str(path), "status": "modified"})
+    return {"files": changed}
+
+
+def run_apply_patch_cli(*, cwd: Path, patch: str) -> int:
+    try:
+        result = apply_patch(patch, cwd.resolve(strict=False))
+    except Exception as error:
+        print(json.dumps({"error": str(error)}))
+        return 1
+    print(json.dumps(result))
+    return 0

package/backend/src/flowent/paths.py

@@ -0,0 +1,11 @@
+import os
+from pathlib import Path
+
+DEFAULT_DATA_DIR = Path.home() / ".flowent"
+
+
+def data_directory() -> Path:
+    configured_directory = os.environ.get("FLOWENT_DATA_DIR")
+    if configured_directory:
+        return Path(configured_directory).expanduser()
+    return DEFAULT_DATA_DIR