bevor-cli 0.1.0__py3-none-any.whl

bevor_cli/commands/analyses/chats/list.py

@@ -0,0 +1,64 @@
+"""``bevor analysis chats list``."""
+
+from typing import Annotated, Optional
+
+import typer
+from bevor_sdk.types.requests.chat import ChatsQueryParams
+from rich.table import Table
+
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.annotations.query import ORDER, ORDER_BY, PAGE, PAGE_SIZE
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.settings import Settings
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def list_chats(
+    page: PAGE,
+    page_size: PAGE_SIZE,
+    order: ORDER,
+    order_by: ORDER_BY,
+    project: Annotated[Optional[str], typer.Option("--project", help="project to list chats for")],
+    json_out: JSON_OUT = False,
+) -> None:
+    """List chats. Uses the currently configured project, or --project"""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    settings = Settings.load()
+    workspace_id = state.validate_workspace()
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project(priority=project)
+    )
+
+    query_params = ChatsQueryParams(
+        page=page,
+        page_size=page_size or settings.default_page_size,
+        order=order,
+        order_by=order_by,
+    )
+
+    found = client.chats.list(options=query_params)
+
+    if json_out:
+        console.print_json(found.model_dump_json(indent=2))
+        return
+
+    if not found.results:
+        console.print("No chats found.")
+        return
+
+    table = Table("ID", "Title", "Code", "Version", "Created")
+    for c in found.results:
+        table.add_row(
+            str(c.id),
+            c.title or "",
+            str(c.code_id),
+            str(c.version_id or ""),
+            str(c.created_at.date()),
+        )
+
+    console.print(table)

bevor_cli/commands/analyses/chats/messages.py

@@ -0,0 +1,41 @@
+"""``bevor analyses chats messages``."""
+
+import json
+
+import typer
+from bevor_sdk.types import ID
+
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def chat_messages(
+    chat_id: str = typer.Argument(..., help="Chat ID."),
+    json_out: JSON_OUT = False,
+) -> None:
+    """Get chat messages for a chat."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    messages = client.chats.messages(ID(chat_id))
+
+    if json_out:
+        console.print_json(
+            json.dumps([m.model_dump(mode="json") for m in messages.results], indent=2)
+        )
+        return
+
+    for m in messages.results:
+        role = m.chat_role or ""
+        text = m.message or ""
+        console.print(f"[{str(role):>9}] {text[:120]}")

bevor_cli/commands/analyses/chats/new.py

@@ -0,0 +1,44 @@
+from typing import Literal
+
+import typer
+
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.commands.analyses.chats.session import _open_streaming_session
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+
+
+def chat_new(
+    mode: Literal["analysis", "code"] = typer.Argument(
+        ..., help="whether to create a chat with analysis or code"
+    ),
+) -> None:
+    """Create a chat thread and open the streaming terminal session. The mode determines if you want
+    to chat with just code, or with analysis + code. Either use your current configuration."""
+
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    if mode == "analysis":
+        analysis_id = state.validate_analysis()
+        analysis = client.analyses.get(analysis_id)
+        created = client.chats.create_for_analysis(version_id=analysis.version.id)
+        _open_streaming_session(
+            client,
+            analysis_id=analysis_id,
+            version_id=analysis.version.id,
+            thread_id=created.id,
+        )
+    elif mode == "code":
+        code_id = state.validate_code()
+        created = client.chats.create_for_code(code_id=code_id)
+        _open_streaming_session(client, analysis_id=None, thread_id=created.id)
+    else:
+        raise typer.Exit(1)

bevor_cli/commands/analyses/chats/resume.py

@@ -0,0 +1,43 @@
+"""``bevor chats`` — interactive streaming chat for the active security analysis."""
+
+from __future__ import annotations
+
+import typer
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.commands.analyses.chats.session import (
+    _ensure_thread_matches_analysis,
+    _open_streaming_session,
+)
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+
+
+def chat_resume(
+    chat_id: str = typer.Argument(
+        ...,
+        metavar="CHAT_ID",
+        help="Thread id (`bevor chats list --json`, field id).",
+    ),
+) -> None:
+    """Open the streaming session for an existing thread."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    if not state.analysis_id:
+        output.error(
+            "No analysis is configured.",
+            hint="Run `bevor analyses select` or `bevor analyses create`.",
+        )
+        raise typer.Exit(1)
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+    tid = chat_id.strip()
+    _ensure_thread_matches_analysis(client, tid, state.analysis_id)
+    _open_streaming_session(client, analysis_id=state.analysis_id, thread_id=tid)

bevor_cli/commands/analyses/chats/session.py

@@ -0,0 +1,295 @@
+"""``bevor chats`` — interactive streaming chat for the active security analysis."""
+
+from __future__ import annotations
+
+import itertools
+import sys
+import threading
+from typing import Any, Dict, List
+
+import httpx
+import questionary
+import typer
+from bevor_sdk._sync.resources.chat.chats import BoundChatResources
+from bevor_sdk.types import ID
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.live import Live
+from rich.markdown import CodeBlock, Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalClient
+
+_CHAT_STYLE = questionary.Style(
+    [
+        ("highlighted", "bold"),
+        ("selected", "bold fg:ansibrightyellow"),
+        ("instruction", "fg:ansibrightblack italic"),
+        ("pointer", "bold fg:ansibrightyellow"),
+    ]
+)
+
+_STREAM_HTTP_TIMEOUT = httpx.Timeout(600.0, connect=60.0)
+
+
+def _recv_spinner(stop: threading.Event) -> None:
+    frames = itertools.cycle("⠋⠙⠹⠸⠼⠴⠦⠇⠏")
+    while not stop.is_set():
+        sys.stdout.write(f"\r\033[2K{next(frames)} Receiving…")
+        sys.stdout.flush()
+        stop.wait(0.09)
+    sys.stdout.write("\r\033[2K")
+    sys.stdout.flush()
+
+
+def _stream_fence_buffer(content: str) -> str:
+    """Synthetic closing fence for render only (same rule as web ``setBuffer('\\n```')`` when odd)."""
+    if content.count("```") % 2 != 0:
+        return "\n```"
+    return ""
+
+
+def _stream_markdown_markup(streamed_content: str) -> str:
+    """What the UI renders: ``streamedContent + buffer``."""
+    return streamed_content + _stream_fence_buffer(streamed_content)
+
+
+class _PlainCodeBlock(CodeBlock):
+    """Fenced bodies during SSE: monospace wrap only — Rich's default uses Pygments and stalls."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        code = str(self.text).rstrip()
+        yield Text(code, style=self.style_name, overflow="fold")
+
+
+class _StreamingLiveMarkdown(Markdown):
+    elements = {**Markdown.elements, "code_block": _PlainCodeBlock}
+
+
+def _stream_markdown_renderable(markup: str) -> Markdown:
+    return _StreamingLiveMarkdown(markup)
+
+
+def _run_stream_turn(
+    bound: BoundChatResources,
+    *,
+    http: httpx.Client,
+    message: str,
+    approval_id: str | None,
+    is_approved: bool | None,
+) -> tuple[List[str], str | None, str | None]:
+    """Consume one POST /stream response.
+
+    Returns ``([], approval_tool_id, approval_prompt)`` — reference events are ignored in the CLI.
+
+    Text events mirror the web client: ``streamedContent`` is the raw payload; for Markdown we append a
+    closing-fence buffer when ``` count is odd. Live updates use markdown with plain fenced bodies so
+    Pygments is not invoked on every chunk (that was freezing the stream once a fence opened).
+    """
+    kw: Dict[str, Any] = {
+        "message": message,
+        "client": http,
+    }
+    if approval_id is not None:
+        kw["approval_id"] = approval_id
+        kw["is_approved"] = bool(is_approved)
+
+    references: List[str] = []
+    pending_tool: str | None = None
+    pending_prompt: str | None = None
+
+    stream_live: Live | None = None
+    live_text_active = False
+    final_stream_text: str | None = None
+
+    spinner_stop = threading.Event()
+    spinner_thread: threading.Thread | None = None
+
+    def stop_recv_spinner() -> None:
+        nonlocal spinner_thread
+        spinner_stop.set()
+        if spinner_thread is not None:
+            spinner_thread.join(timeout=1.0)
+            spinner_thread = None
+
+    def stop_stream_live() -> None:
+        nonlocal stream_live
+        if stream_live is not None:
+            stream_live.stop()
+            stream_live = None
+
+    def flush_streamed_markdown(*, quiet_plain_fallback: bool) -> None:
+        nonlocal live_text_active, final_stream_text
+        stop_stream_live()
+        if quiet_plain_fallback and final_stream_text is not None:
+            output.console.print(
+                Markdown(_stream_markdown_markup(final_stream_text)),
+                end="\n",
+            )
+        live_text_active = False
+        final_stream_text = None
+
+    output.console.print("\n[bold cyan]Assistant[/bold cyan]")
+    sys.stdout.flush()
+
+    if not output.is_quiet():
+        spinner_thread = threading.Thread(
+            target=_recv_spinner,
+            args=(spinner_stop,),
+            daemon=True,
+        )
+        assert spinner_thread
+        spinner_thread.start()
+
+    try:
+        for obj in bound.stream(**kw):
+            if not obj:
+                continue
+            stop_recv_spinner()
+
+            if obj.event_type == "text":
+                raw = str(obj.content or "")
+                final_stream_text = raw
+                markup = _stream_markdown_markup(raw)
+                if output.is_quiet():
+                    live_text_active = True
+                    continue
+                md = _stream_markdown_renderable(markup)
+                if stream_live is None:
+                    stream_live = Live(
+                        md,
+                        console=output.console,
+                        refresh_per_second=15,
+                        transient=False,
+                        vertical_overflow="visible",
+                        redirect_stdout=False,
+                        redirect_stderr=False,
+                    )
+                    assert stream_live
+                    stream_live.start()
+                else:
+                    stream_live.update(md)
+                live_text_active = True
+                continue
+
+            if live_text_active:
+                flush_streamed_markdown(quiet_plain_fallback=output.is_quiet())
+
+            if obj.event_type == "thinking":
+                output.console.print(f"[dim italic]{obj.content or 'thinking…'}[/dim italic]")
+                continue
+
+            if obj.event_type == "tool-call":
+                output.console.print(f"[dim]tool[/dim] [yellow]{obj.content}[/yellow]")
+                continue
+
+            if obj.event_type == "approval":
+                pending_tool = obj.id
+                pending_prompt = obj.content or "Approve this tool call?"
+                break
+
+            if obj.event_type == "failure":
+                output.console.print(f"[bold red]{obj.content or 'Request failed'}[/bold red]")
+                break
+
+            if obj.event_type == "reference":
+                continue
+
+            if live_text_active:
+                flush_streamed_markdown(quiet_plain_fallback=output.is_quiet())
+    finally:
+        stop_recv_spinner()
+
+    return references, pending_tool, pending_prompt
+
+
+def _session_banner(*, analysis_id: str | None, version_id: str | None, thread_id: str) -> None:
+    context = ""
+    if analysis_id:
+        context += f"[bold]Analysis[/bold] {analysis_id}\n"
+    if version_id:
+        context += f"[bold]Version[/bold]  {version_id}\n"
+    output.console.print(
+        Panel.fit(
+            f"{context}[bold]Thread[/bold]   {thread_id}\n\n"
+            "[dim]/quit · /exit · Ctrl+D · requires synced code (`bevor codes push`)[/dim]",
+            title="Bevor Chat",
+            border_style="blue",
+        )
+    )
+
+
+def _ensure_thread_matches_analysis(security: BevorInternalClient, thread_id: str, aid: str) -> None:
+    chat = security.chats.get(ID(thread_id))
+    if chat.version_id is not None and str(chat.version_id) != aid:
+        output.error(
+            f"Chat {thread_id} belongs to another analysis ({chat.version_id}).",
+            hint="Pick a thread from `bevor chats list` or run `bevor analyses select`.",
+        )
+        raise typer.Exit(1)
+
+
+def _open_streaming_session(
+    security: BevorInternalClient,
+    *,
+    analysis_id: str | None,
+    version_id: str | None = None,
+    thread_id: str,
+) -> None:
+    _session_banner(analysis_id=analysis_id, version_id=version_id, thread_id=thread_id)
+    try:
+        _interactive_loop(security, thread_id=thread_id)
+    except KeyboardInterrupt:
+        output.console.print("\n[dim]Interrupted.[/dim]")
+
+
+def _interactive_loop(client: BevorInternalClient, *, thread_id: str) -> None:
+    bound = client.chats(ID(thread_id))
+
+    with httpx.Client(timeout=_STREAM_HTTP_TIMEOUT) as http:
+        while True:
+            user_line = questionary.text(
+                "You ›",
+                qmark="",
+                style=_CHAT_STYLE,
+            ).ask()
+
+            if user_line is None:
+                output.console.print("[dim]Goodbye.[/dim]")
+                break
+
+            text = user_line.strip()
+            if not text:
+                continue
+            low = text.lower()
+            if low in ("/quit", "/exit", ":q", "exit", "quit"):
+                output.console.print("[dim]Goodbye.[/dim]")
+                break
+
+            approval_id: str | None = None
+            is_approved: bool | None = None
+
+            while True:
+                refs, pending_tool, pending_prompt = _run_stream_turn(
+                    bound,
+                    http=http,
+                    message=text,
+                    approval_id=approval_id,
+                    is_approved=is_approved,
+                )
+
+                if pending_tool:
+                    choice = questionary.confirm(
+                        pending_prompt or "Approve tool execution?",
+                        default=False,
+                        style=_CHAT_STYLE,
+                    ).ask()
+                    approved = bool(choice) if choice is not None else False
+                    approval_id = pending_tool
+                    is_approved = approved
+                    continue
+
+                for row in refs:
+                    output.console.print(row)
+                break

bevor_cli/commands/analyses/child.py

@@ -0,0 +1,81 @@
+"""``bevor analysis child`` — create a child version on new code."""
+
+from typing import Literal, Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.security import CreateAnalysisChildBodyDict
+from bevor_sdk.types.responses.security import AnalysisCollisionResult, AnalysisCreatedResult
+from rich.table import Table
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def create_child_analysis(
+    version: Optional[str] = typer.Option(
+        None,
+        "--version",
+        help="Parent version id (default: configured analysis head).",
+    ),
+    collision: Optional[Literal["surface", "force", "merge"]] = typer.Option(
+        "surface",
+        "--collision",
+        help="What Bevor should do if analysis already exists for the given code",
+    ),
+) -> None:
+    """Create a child analysis version using the configured code. If there is no currently configured
+    analysis (`bevor context` or `bevor analyses view`), you can pass a --version, or you can select an analysis
+    using `bevor analyses select`. Bevor will check whether an analysis
+    exists for the given code version or not, and early return if so. Use the --collision argument to bypass this,
+    but it's advised not to."""
+
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    code_id = state.validate_code()
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    body = CreateAnalysisChildBodyDict(code_id=code_id, on_collision=collision)
+    if version:
+        v_ = client.analysis_versions.get(ID(version))
+        analysis_id = v_.analysis_meta.id
+        version_id = v_.id
+        body["version_id"] = version_id
+    else:
+        analysis_id = state.validate_analysis()
+
+    created = client.analyses.create_child(analysis_id, body)
+
+    if isinstance(created, AnalysisCreatedResult):
+        state.set_analysis(created.analysis)
+        state.save()
+
+        output.success(
+            f"Child analysis version created: {created.analysis.version.id} "
+            f"(analysis {created.analysis.id})."
+        )
+    elif isinstance(created, AnalysisCollisionResult):
+        output.warning(
+            f"{len(created.candidates)} analysis versions already exist for this code version. They're listed out with the proposed actions. "
+            "if you want to create the analysis version anyways, use the --collision=force flag."
+        )
+        table = Table("ID", "Name", "Created", "User", "Action")
+        for candidate in created.candidates:
+            args = [
+                candidate.id,
+                candidate.analysis_meta.name,
+                str(candidate.created_at.date()),
+                candidate.analysis_meta.user.username,
+                candidate.on_collision,
+            ]
+            table.add_row(*args)
+        console.print(table)

bevor_cli/commands/analyses/commit.py

@@ -0,0 +1,49 @@
+"""``bevor analysis commit`` — commit staged finding changes."""
+
+from typing import Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.security import VersionBodyDict
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+
+
+def commit_analysis(
+    version: Optional[str] = typer.Option(
+        None,
+        "--version",
+        help="Version id to commit (default: configured analysis head).",
+    ),
+) -> None:
+    """Commit staged findings for an analysis. This will update the HEAD of the configured analysis, or of the
+    analysis associated to the --version."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    analysis_id = state.validate_analysis()
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    body = VersionBodyDict()
+    if version:
+        v_ = client.analysis_versions.get(ID(version))
+        analysis_id = v_.analysis_meta.id
+        version_id = v_.id
+        body["version_id"] = version_id
+    else:
+        analysis_id = state.validate_analysis()
+
+    result = client.analyses.commit(analysis_id, body)
+
+    state.set_analysis(result)
+    state.save()
+
+    output.success(f"Committed changes → new head {result.version.id} (analysis {result.id}).")