flowent 0.0.6 → 0.0.10

package/backend/src/flowent/cli.py

@@ -3,23 +3,17 @@ from __future__ import annotations
 import argparse
 import os
 import sys
-
-APP_DATA_DIR_ENV_VAR = "FLOWENT_APP_DATA_DIR"
+from pathlib import Path
 
 
 def main(argv: list[str] | None = None) -> None:
     parser = argparse.ArgumentParser(
         prog="flowent",
-        description="Flowent — multi-agent collaboration framework",
+        description="Flowent",
     )
     subparsers = parser.add_subparsers(dest="command")
-    access_parser = subparsers.add_parser("access", help="Flowent access commands")
-    access_subparsers = access_parser.add_subparsers(dest="access_command")
-    access_subparsers.add_parser(
-        "refresh",
-        help="Generate and persist a new admin access code",
-    )
-    access_subparsers.add_parser("reset", help="Clear the persisted admin access code")
+    apply_patch_parser = subparsers.add_parser("apply-patch", help=argparse.SUPPRESS)
+    apply_patch_parser.add_argument("--cwd", required=True)
     parser.add_argument(
         "--host",
         "--hostname",
@@ -42,24 +36,16 @@ def main(argv: list[str] | None = None) -> None:
     parser.add_argument(
         "--app-data-dir",
         default="",
-        help="Override the Flowent app data directory for this process",
+        help=argparse.SUPPRESS,
     )
     args = parser.parse_args(argv)
 
-    if isinstance(args.app_data_dir, str) and args.app_data_dir.strip():
-        os.environ[APP_DATA_DIR_ENV_VAR] = args.app_data_dir.strip()
-
-    if args.command == "access" and args.access_command == "refresh":
-        from flowent.access import refresh_local_access
-
-        print(refresh_local_access())
-        return
-
-    if args.command == "access" and args.access_command == "reset":
-        from flowent.access import reset_local_access
+    if args.command == "apply-patch":
+        from flowent.patch import run_apply_patch_cli
 
-        print(reset_local_access())
-        return
+        raise SystemExit(
+            run_apply_patch_cli(cwd=Path(args.cwd), patch=sys.stdin.read())
+        )
 
     if args.version:
         try:
@@ -72,6 +58,15 @@ def main(argv: list[str] | None = None) -> None:
         print(f"flowent {ver}")
         sys.exit(0)
 
+    from flowent.logging import configure_logging
+
+    configure_logging()
+
+    import logging
+
+    logger = logging.getLogger("flowent.cli")
+    logger.info("Starting Flowent on %s:%s", args.host, args.port)
+
     import uvicorn
 
     uvicorn.run(

package/backend/src/flowent/context.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from flowent.llm import ChatMessage
+from flowent.tools import tool_specs
+
+DEFAULT_PROJECT_INSTRUCTIONS_MAX_BYTES = 32768
+PROJECT_DOC_FILENAME = "AGENTS.md"
+PROJECT_DOC_OVERRIDE_FILENAME = "AGENTS.override.md"
+
+
+def project_instructions_max_bytes() -> int:
+    raw_limit = os.environ.get("FLOWENT_PROJECT_INSTRUCTIONS_MAX_BYTES", "")
+    try:
+        return max(0, int(raw_limit))
+    except ValueError:
+        return DEFAULT_PROJECT_INSTRUCTIONS_MAX_BYTES
+
+
+def project_root(cwd: Path) -> Path:
+    resolved_cwd = cwd.resolve(strict=False)
+    for ancestor in (resolved_cwd, *resolved_cwd.parents):
+        if (ancestor / ".git").exists():
+            return ancestor
+    return resolved_cwd
+
+
+def project_doc_path(directory: Path) -> Path | None:
+    override = directory / PROJECT_DOC_OVERRIDE_FILENAME
+    if override.is_file() or override.is_symlink():
+        return override
+    project_doc = directory / PROJECT_DOC_FILENAME
+    if project_doc.is_file() or project_doc.is_symlink():
+        return project_doc
+    return None
+
+
+def project_doc_paths(cwd: Path) -> list[Path]:
+    root = project_root(cwd)
+    resolved_cwd = cwd.resolve(strict=False)
+    directories: list[Path] = []
+    current = resolved_cwd
+    while True:
+        directories.append(current)
+        if current == root:
+            break
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    return [
+        doc_path
+        for directory in reversed(directories)
+        if (doc_path := project_doc_path(directory)) is not None
+    ]
+
+
+def read_project_instructions(cwd: Path) -> str:
+    remaining_bytes = project_instructions_max_bytes()
+    if remaining_bytes <= 0:
+        return ""
+
+    sections: list[str] = []
+    for path in project_doc_paths(cwd):
+        if remaining_bytes <= 0:
+            break
+        try:
+            content = path.read_bytes()[:remaining_bytes]
+        except OSError:
+            continue
+        text = content.decode(errors="replace")
+        if text.strip():
+            sections.append(text)
+            remaining_bytes -= len(content)
+
+    return "\n\n".join(sections)
+
+
+def project_instructions_message(cwd: Path) -> ChatMessage | None:
+    instructions = read_project_instructions(cwd)
+    if not instructions:
+        return None
+    return ChatMessage(
+        role="user",
+        content=(
+            f"# AGENTS.md instructions for {cwd.resolve(strict=False)}\n\n"
+            f"<INSTRUCTIONS>\n{instructions}\n</INSTRUCTIONS>"
+        ),
+    )
+
+
+def tool_names() -> list[str]:
+    names: list[str] = []
+    for spec in tool_specs():
+        function = spec.get("function")
+        if isinstance(function, dict) and isinstance(function.get("name"), str):
+            names.append(function["name"])
+    return names
+
+
+def environment_context_message(cwd: Path) -> ChatMessage:
+    rendered_tools = "\n".join(f"  <tool>{name}</tool>" for name in tool_names())
+    return ChatMessage(
+        role="user",
+        content=(
+            "<environment_context>\n"
+            f"  <cwd>{cwd.resolve(strict=False)}</cwd>\n"
+            "  <filesystem>workspace-write</filesystem>\n"
+            "  <network>enabled</network>\n"
+            "  <tools>\n"
+            f"{rendered_tools}\n"
+            "  </tools>\n"
+            "</environment_context>"
+        ),
+    )
+
+
+def runtime_context_messages(cwd: Path) -> list[ChatMessage]:
+    messages: list[ChatMessage] = []
+    project_message = project_instructions_message(cwd)
+    if project_message is not None:
+        messages.append(project_message)
+    messages.append(environment_context_message(cwd))
+    return messages

package/backend/src/flowent/llm.py

@@ -0,0 +1,256 @@
+import logging
+from collections.abc import AsyncIterator, Awaitable, Mapping, Sequence
+from enum import StrEnum
+from typing import Any, Literal, Protocol
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from flowent.logging import TRACE_LEVEL, configure_litellm_logging
+
+
+class ProviderFormat(StrEnum):
+    OPENAI = "openai"
+    OPENAI_RESPONSES = "openai_responses"
+    ANTHROPIC = "anthropic"
+    GEMINI = "gemini"
+
+
+class ProviderConnection(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    name: str = Field(min_length=1)
+    provider: ProviderFormat
+    model: str = Field(min_length=1)
+    secret_reference: str = Field(min_length=1)
+    base_url: str | None = None
+
+
+class ChatMessage(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class ToolCallDelta(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    arguments: str = ""
+    id: str = ""
+    index: int = 0
+    name: str = ""
+    type: str = "function"
+
+
+class CompletionCallable(Protocol):
+    def __call__(self, **kwargs: Any) -> Awaitable[Any]: ...
+
+
+class ModelListCallable(Protocol):
+    def __call__(self, **kwargs: Any) -> Sequence[str]: ...
+
+
+logger = logging.getLogger("flowent.llm")
+
+
+MODEL_PREFIXES: dict[ProviderFormat, str] = {
+    ProviderFormat.OPENAI: "openai",
+    ProviderFormat.OPENAI_RESPONSES: "openai",
+    ProviderFormat.ANTHROPIC: "anthropic",
+    ProviderFormat.GEMINI: "gemini",
+}
+
+
+def provider_model_name(connection: ProviderConnection) -> str:
+    return f"{MODEL_PREFIXES[connection.provider]}/{connection.model}"
+
+
+def provider_litellm_name(provider: ProviderFormat) -> str:
+    return MODEL_PREFIXES[provider]
+
+
+def normalize_provider_model_name(provider: ProviderFormat, model: str) -> str:
+    prefix = f"{provider_litellm_name(provider)}/"
+    if model.startswith(prefix):
+        return model.removeprefix(prefix)
+    return model
+
+
+def unique_model_names(provider: ProviderFormat, models: Sequence[str]) -> list[str]:
+    seen: set[str] = set()
+    normalized_models: list[str] = []
+    for model in models:
+        normalized_model = normalize_provider_model_name(provider, model)
+        if normalized_model in seen:
+            continue
+        seen.add(normalized_model)
+        normalized_models.append(normalized_model)
+    return normalized_models
+
+
+def list_provider_models(
+    *,
+    provider: ProviderFormat,
+    secret_reference: str,
+    base_url: str | None = None,
+    model_lister: ModelListCallable | None = None,
+) -> list[str]:
+    if model_lister is None:
+        from litellm import get_valid_models
+
+        configure_litellm_logging()
+        model_lister = get_valid_models
+
+    models = model_lister(
+        api_base=base_url,
+        api_key=secret_reference,
+        check_provider_endpoint=True,
+        custom_llm_provider=provider_litellm_name(provider),
+    )
+    return unique_model_names(provider, models)
+
+
+def build_litellm_request(
+    connection: ProviderConnection,
+    messages: Sequence[ChatMessage | Mapping[str, Any]],
+    *,
+    stream: bool = False,
+    tools: Sequence[Mapping[str, Any]] | None = None,
+) -> dict[str, Any]:
+    request_messages = [
+        message.model_dump() if isinstance(message, ChatMessage) else dict(message)
+        for message in messages
+    ]
+    request: dict[str, Any] = {
+        "api_key": connection.secret_reference,
+        "messages": request_messages,
+        "model": provider_model_name(connection),
+    }
+    if tools:
+        request["tools"] = list(tools)
+    if stream:
+        request["stream"] = True
+    if connection.base_url:
+        request["api_base"] = connection.base_url
+    logger.log(
+        TRACE_LEVEL,
+        "Built LiteLLM request provider=%s model=%s base_url=%s stream=%s tools=%s messages=%r",
+        connection.provider,
+        connection.model,
+        connection.base_url or "",
+        stream,
+        bool(tools),
+        request_messages,
+    )
+    return request
+
+
+async def complete_chat(
+    connection: ProviderConnection,
+    messages: Sequence[ChatMessage | Mapping[str, Any]],
+    *,
+    completion: CompletionCallable | None = None,
+    tools: Sequence[Mapping[str, Any]] | None = None,
+) -> ChatMessage:
+    if completion is None:
+        from litellm import acompletion
+
+        configure_litellm_logging()
+        completion = acompletion
+
+    logger.debug(
+        "Starting LLM completion provider=%s model=%s",
+        connection.provider,
+        connection.model,
+    )
+    response = await completion(
+        **build_litellm_request(connection, messages, tools=tools)
+    )
+    logger.log(TRACE_LEVEL, "LLM completion response=%r", response)
+    choice = response["choices"][0]["message"]
+    return ChatMessage(role=choice.get("role", "assistant"), content=choice["content"])
+
+
+def value_at(value: Any, key: str, default: Any = None) -> Any:
+    if isinstance(value, Mapping):
+        return value.get(key, default)
+    return getattr(value, key, default)
+
+
+def chunk_delta_content(chunk: Any) -> str:
+    try:
+        content = chunk.choices[0].delta.content
+    except (AttributeError, IndexError, TypeError):
+        try:
+            content = chunk["choices"][0]["delta"].get("content")
+        except (KeyError, IndexError, TypeError, AttributeError):
+            return ""
+    return content if isinstance(content, str) else ""
+
+
+def chunk_delta_tool_calls(chunk: Any) -> list[ToolCallDelta]:
+    try:
+        choice = chunk.choices[0]
+        delta = choice.delta
+    except (AttributeError, IndexError, TypeError):
+        try:
+            delta = chunk["choices"][0]["delta"]
+        except (KeyError, IndexError, TypeError):
+            return []
+
+    raw_tool_calls = value_at(delta, "tool_calls", [])
+    if not raw_tool_calls:
+        return []
+
+    tool_call_deltas: list[ToolCallDelta] = []
+    for position, raw_tool_call in enumerate(raw_tool_calls):
+        function = value_at(raw_tool_call, "function", {})
+        index = value_at(raw_tool_call, "index", position)
+        tool_call_deltas.append(
+            ToolCallDelta(
+                arguments=value_at(function, "arguments", "") or "",
+                id=value_at(raw_tool_call, "id", "") or "",
+                index=index if isinstance(index, int) else position,
+                name=value_at(function, "name", "") or "",
+                type=value_at(raw_tool_call, "type", "function") or "function",
+            )
+        )
+    return tool_call_deltas
+
+
+async def stream_chat_chunks(
+    connection: ProviderConnection,
+    messages: Sequence[ChatMessage | Mapping[str, Any]],
+    *,
+    completion: CompletionCallable | None = None,
+    tools: Sequence[Mapping[str, Any]] | None = None,
+) -> AsyncIterator[Any]:
+    if completion is None:
+        from litellm import acompletion
+
+        configure_litellm_logging()
+        completion = acompletion
+
+    logger.debug(
+        "Starting streaming LLM completion provider=%s model=%s",
+        connection.provider,
+        connection.model,
+    )
+    response = await completion(
+        **build_litellm_request(connection, messages, stream=True, tools=tools)
+    )
+    async for chunk in response:
+        logger.log(TRACE_LEVEL, "LLM stream chunk=%r", chunk)
+        yield chunk
+
+
+async def stream_chat(
+    connection: ProviderConnection,
+    messages: Sequence[ChatMessage | Mapping[str, Any]],
+    *,
+    completion: CompletionCallable | None = None,
+) -> AsyncIterator[str]:
+    async for chunk in stream_chat_chunks(connection, messages, completion=completion):
+        content = chunk_delta_content(chunk)
+        if content:
+            yield content