bevor-cli 0.1.0__py3-none-any.whl

bevor_cli/annotations/confirmations.py

@@ -0,0 +1,16 @@
+from typing import Annotated
+
+import typer
+
+YES = Annotated[bool, typer.Option("--yes", help="Skip confirmation of action.")]
+NO_WAIT = Annotated[
+    bool,
+    typer.Option(
+        "--no-wait", help="Return immediately without waiting for the event stream to complete."
+    ),
+]
+JSON_OUT = Annotated[bool, typer.Option("--json", help="JSON output")]
+FORCE = Annotated[bool, typer.Option("--force", help="Skip checks. Not recommended.")]
+SILENT = Annotated[bool, typer.Option("--silent", help="Suppress intermediate output logs.")]
+
+__all__ = ["YES", "JSON_OUT", "NO_WAIT", "FORCE", "SILENT"]

bevor_cli/annotations/query.py

@@ -0,0 +1,25 @@
+from typing import Annotated, Literal
+
+import typer
+
+PAGE = Annotated[
+    int | None,
+    typer.Option("--page", help="Page number to use for resource that supports pagination"),
+]
+PAGE_SIZE = Annotated[
+    int | None,
+    typer.Option("--page-size", help="Page size to use for resource that supports pagination"),
+]
+ORDER = Annotated[
+    Literal["desc", "asc"] | None,
+    typer.Option("--order", help="How to order results when a resource supports pagination"),
+]
+
+ORDER_BY = Annotated[
+    Literal["created_at", "updated_at"] | None,
+    typer.Option(
+        "--order-by", help="What field to order results by when a resource supports pagination"
+    ),
+]
+
+__all__ = ["PAGE", "PAGE_SIZE", "ORDER", "ORDER_BY"]

bevor_cli/apps/agent.py

@@ -0,0 +1,10 @@
+import typer
+from bevor_cli.commands.agent.materialze_cmd import scopes_materialize
+from bevor_cli.commands.agent.setup_cmd import agent_setup
+
+app = typer.Typer(help="Audit agent workflow shorthands.", no_args_is_help=True)
+
+app.command("setup")(agent_setup)
+app.command("materialize")(scopes_materialize)
+
+__all__ = ["app"]

bevor_cli/apps/analyses.py

@@ -0,0 +1,47 @@
+import typer
+from bevor_cli.commands.analyses.active import active_analysis
+from bevor_cli.commands.analyses.child import create_child_analysis
+from bevor_cli.commands.analyses.commit import commit_analysis
+from bevor_cli.commands.analyses.create import create_analysis
+from bevor_cli.commands.analyses.delete import delete_analysis_full, delete_analysis_version
+from bevor_cli.commands.analyses.diff import diff_analysis
+from bevor_cli.commands.analyses.entrypoints import list_entrypoints
+from bevor_cli.commands.analyses.findings import list_analysis_findings
+from bevor_cli.commands.analyses.fork import fork_analysis
+from bevor_cli.commands.analyses.list import list_analyses
+from bevor_cli.commands.analyses.merge import merge_analysis
+from bevor_cli.commands.analyses.retry import retry_analysis
+from bevor_cli.commands.analyses.run import run_analysis
+from bevor_cli.commands.analyses.select import select_analysis
+from bevor_cli.commands.analyses.set_head import set_analysis_head
+from bevor_cli.commands.analyses.transitions import list_transitions
+from bevor_cli.commands.analyses.view import view_analysis
+
+app = typer.Typer(help="Manage analyses.", no_args_is_help=True)
+
+app.command("list")(list_analyses)
+app.command("view")(view_analysis)
+app.command("select")(select_analysis)
+app.command("recent")(active_analysis)
+app.command("create")(create_analysis)
+app.command("set-head")(set_analysis_head)
+
+delete_app = typer.Typer(help="Delete an analysis container or version.", no_args_is_help=True)
+delete_app.command("full")(delete_analysis_full)
+delete_app.command("version")(delete_analysis_version)
+app.add_typer(delete_app, name="delete")
+
+app.command("run")(run_analysis)
+app.command("retry")(retry_analysis)
+app.command("diff")(diff_analysis)
+app.command("commit")(commit_analysis)
+app.command("child")(create_child_analysis)
+app.command("fork")(fork_analysis)
+app.command("merge")(merge_analysis)
+app.command("findings")(list_analysis_findings)
+
+
+app.command("entrypoints")(list_entrypoints)
+app.command("transitions")(list_transitions)
+
+__all__ = ["app"]

bevor_cli/apps/chat.py

@@ -0,0 +1,16 @@
+import typer
+from bevor_cli.commands.analyses.chats.get import get_chat
+from bevor_cli.commands.analyses.chats.list import list_chats
+from bevor_cli.commands.analyses.chats.messages import chat_messages
+from bevor_cli.commands.analyses.chats.new import chat_new
+from bevor_cli.commands.analyses.chats.resume import chat_resume
+
+app = typer.Typer(help="Manage analysis chats.")
+
+app.command("list")(list_chats)
+app.command("view")(get_chat)
+app.command("messages")(chat_messages)
+app.command("new")(chat_new)
+app.command("resume")(chat_resume)
+
+__all__ = ["app"]

bevor_cli/apps/codes.py

@@ -0,0 +1,18 @@
+import typer
+from bevor_cli.apps import nodes
+from bevor_cli.commands.codes.list import list_code_versions
+from bevor_cli.commands.codes.push import push_code
+from bevor_cli.commands.codes.select import select_code
+from bevor_cli.commands.codes.view import view_code
+
+app = typer.Typer(
+    help="List, inspect, and upload code versions for the active project.",
+    no_args_is_help=True,
+)
+app.command("list")(list_code_versions)
+app.command("view")(view_code)
+app.command("select")(select_code)
+app.command("push")(push_code)
+app.add_typer(nodes.app, name="nodes")
+
+__all__ = ["app"]

bevor_cli/apps/findings.py

@@ -0,0 +1,22 @@
+import typer
+from bevor_cli.commands.findings.acknowledge import acknowledge_finding
+from bevor_cli.commands.findings.add import add_finding
+from bevor_cli.commands.findings.bulk import bulk_findings
+from bevor_cli.commands.findings.delete import delete_finding
+from bevor_cli.commands.findings.edit import edit_finding
+from bevor_cli.commands.findings.get import get_finding
+from bevor_cli.commands.findings.list import list_findings
+from bevor_cli.commands.findings.revert import revert_finding
+
+app = typer.Typer(help="Findings for the configured analysis.", no_args_is_help=True)
+
+app.command("list")(list_findings)
+app.command("view")(get_finding)
+app.command("add")(add_finding)
+app.command("bulk")(bulk_findings)
+app.command("edit")(edit_finding)
+app.command("delete")(delete_finding)
+app.command("revert")(revert_finding)
+app.command("acknowledge")(acknowledge_finding)
+
+__all__ = ["app"]

bevor_cli/apps/main.py

@@ -0,0 +1,61 @@
+import typer
+from bevor_cli import output
+from bevor_cli.apps import (
+    agent,
+    analyses,
+    chat,
+    codes,
+    findings,
+    projects,
+    sessions,
+    workspaces,
+)
+from bevor_cli.commands.auth import login, logout, whoami
+from bevor_cli.commands.context import run_context
+from bevor_cli.commands.link import run_link
+from bevor_cli.output import console
+
+app = typer.Typer(
+    name="bevor",
+    help="Bevor CLI — smart contract security analysis and code graph exploration.",
+    invoke_without_command=True,
+    no_args_is_help=True,
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback(invoke_without_command=True)
+def _root(
+    quiet: bool = typer.Option(
+        False,
+        "--quiet",
+        help="Suppress informational output; useful for scripting.",
+        is_eager=False,
+    ),
+) -> None:
+    output.set_quiet(quiet)
+
+
+@app.command("help")
+def help_command(ctx: typer.Context) -> None:
+    """Show root help text (alias for --help)."""
+    root_ctx = ctx.parent or ctx
+    console.print(root_ctx.get_help())
+
+
+app.command("login")(login)
+app.command("logout")(logout)
+app.command("whoami")(whoami)
+app.command("link")(run_link)
+app.command("context")(run_context)
+
+app.add_typer(sessions.app, name="sessions")
+app.add_typer(workspaces.app, name="workspaces")
+app.add_typer(projects.app, name="projects")
+app.add_typer(codes.app, name="codes")
+app.add_typer(analyses.app, name="analyses")
+app.add_typer(findings.app, name="findings")
+app.add_typer(agent.app, name="agent")
+app.add_typer(chat.app, name="chats")
+
+__all__ = ["app"]

bevor_cli/apps/nodes.py

@@ -0,0 +1,17 @@
+import typer
+from bevor_cli.commands.graph.call_chain import call_chain_cmd
+from bevor_cli.commands.graph.edges import list_node_edges
+from bevor_cli.commands.graph.interactive import interactive_cmd
+from bevor_cli.commands.nodes.get import get_node
+from bevor_cli.commands.nodes.list import list_nodes
+from bevor_cli.commands.nodes.source import show_source
+
+app = typer.Typer(help="Inspect the code graph.", no_args_is_help=True)
+app.command("list")(list_nodes)
+app.command("view")(get_node)
+app.command("content")(show_source)
+app.command("edges")(list_node_edges)
+app.command("call-chain")(call_chain_cmd)
+app.command("interactive")(interactive_cmd)
+
+__all__ = ["app"]

bevor_cli/apps/projects.py

@@ -0,0 +1,14 @@
+import typer
+from bevor_cli.commands.projects.create import create_project
+from bevor_cli.commands.projects.list import list_projects
+from bevor_cli.commands.projects.select import select_project
+from bevor_cli.commands.projects.view import view_project
+
+app = typer.Typer(help="List, view, select, and create projects.", no_args_is_help=True)
+
+app.command("list")(list_projects)
+app.command("view")(view_project)
+app.command("select")(select_project)
+app.command("create")(create_project)
+
+__all__ = ["app"]

bevor_cli/apps/sessions.py

@@ -0,0 +1,13 @@
+import typer
+from bevor_cli.commands.sessions.list import sessions_list
+from bevor_cli.commands.sessions.revoke import sessions_revoke
+
+app = typer.Typer(
+    help="List and revoke CLI sessions.",
+    no_args_is_help=True,
+)
+
+app.command("list")(sessions_list)
+app.command("revoke")(sessions_revoke)
+
+__all__ = ["app"]

bevor_cli/apps/workspaces.py

@@ -0,0 +1,16 @@
+import typer
+from bevor_cli.commands.workspaces.list import list_workspaces
+from bevor_cli.commands.workspaces.pick import pick_workspace
+from bevor_cli.commands.workspaces.select import select_workspace
+from bevor_cli.commands.workspaces.view import view_workspace
+
+app = typer.Typer(
+    help="List, view, and select workspaces.",
+    no_args_is_help=True,
+)
+
+app.command("list")(list_workspaces)
+app.command("view")(view_workspace)
+app.command("select")(select_workspace)
+
+__all__ = ["app", "pick_workspace"]

bevor_cli/client.py

@@ -0,0 +1,157 @@
+"""Thin httpx wrapper that injects auth headers for the Bevor API."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, cast
+
+import httpx
+import typer
+from bevor_sdk import BevorClient
+from bevor_sdk.exceptions import ERROR_REGISTRY, AppErrorTypes
+from bevor_sdk.types.requests.manage import CreateProjectBodyDict
+from bevor_sdk.types.responses import ResultsResponse
+from bevor_sdk.types.responses.manage import (
+    ProjectSchema,
+    UserDetailedSchema,
+    WorkspaceDetailedSchema,
+)
+from httpx._types import QueryParamTypes, TimeoutTypes
+
+from bevor_cli import output
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.settings import API_URL
+
+
+class BevorInternalClient(BevorClient):
+    """Public SDK client authenticated with the CLI's user token.
+
+    Project-level endpoints resolve scope from the injected headers, so pass ``project_id`` for anything below
+    project selection.
+    """
+
+    def __init__(
+        self,
+        creds: Credentials,
+        workspace_id: str | None = None,
+        project_id: str | None = None,
+    ) -> None:
+        headers = {}
+
+        if not creds.token:
+            output.error("Not Authenticated", hint="Run `bevor login`.")
+            raise typer.Exit(1)
+
+        if workspace_id:
+            headers.update({"bevor-workspace-id": workspace_id})
+        if project_id:
+            headers.update({"bevor-project-id": project_id})
+        super().__init__(api_key=creds.token, base_url=API_URL, default_headers=headers)
+
+
+class BevorInternalBusinessClient(httpx.Client):
+    """User-scoped endpoints that API keys can't reach: navigation above the project, sessions."""
+
+    _TIMEOUT = httpx.Timeout(10.0)
+
+    def __init__(
+        self, creds: Credentials, workspace_id: str | None = None, timeout: TimeoutTypes = None
+    ) -> None:
+        super().__init__(base_url=API_URL, timeout=timeout or self._TIMEOUT)
+
+        if creds.token:
+            self.headers.update({"Authorization": f"Bearer {creds.token}"})
+        if workspace_id:
+            self.headers.update({"Bevor-Workspace-Id": workspace_id})
+
+    def _parse_error_body(
+        self,
+        response: httpx.Response,
+    ) -> tuple[str | None, str, int]:
+        status = response.status_code
+        try:
+            body = response.json()
+            if not isinstance(body, dict):
+                return None, response.text or "no details", status
+            code_raw = body.get("code")
+            code: str | None
+            if code_raw is None:
+                code = None
+            elif isinstance(code_raw, str):
+                code = code_raw
+            else:
+                code = str(code_raw)
+            if body.get("message") is not None:
+                message = str(body.get("message"))
+            else:
+                d = body.get("detail")
+                if d is not None and not isinstance(d, str):
+                    message = str(d)
+                else:
+                    message = str(d) if d is not None else str(body)
+            return code, message, status
+        except Exception:
+            return None, response.text or "no details", status
+
+    def _handle_http_error(self, response: httpx.Response) -> bool:
+        if response.is_success:
+            if response.status_code == 204 or not response.content:
+                return False
+            return True
+
+        code, message, status = self._parse_error_body(response)
+
+        if not code:
+            # couldn't parse, so raise.
+            response.raise_for_status()
+
+        exc_cls = ERROR_REGISTRY.get(cast(AppErrorTypes, code))
+        if exc_cls is None:
+            response.raise_for_status()
+            return False  # just for typing...
+
+        raise exc_cls(message)
+
+    def _prune_query_params(self, params: QueryParamTypes | None = None) -> QueryParamTypes | None:
+        if not params:
+            return None
+        qp = httpx.QueryParams(params)
+        out: Dict[str, Any] = {}
+        for k, v in qp.items():
+            if v is None:
+                continue
+            if v == "":
+                continue
+            if isinstance(v, bool):
+                out[k] = "true" if v else "false"
+            else:
+                out[k] = v
+        return httpx.QueryParams(out) if out else None
+
+    def _merge_queryparams(self, params: QueryParamTypes | None = None) -> QueryParamTypes | None:
+        params = super()._merge_queryparams(params)
+        return self._prune_query_params(params)
+
+    def send(self, request: httpx.Request, **kwargs) -> httpx.Response:
+        response = super().send(request, **kwargs)
+        self._handle_http_error(response)
+        return response
+
+    def me(self) -> UserDetailedSchema:
+        data = self.get("/v1/me").json()
+        return UserDetailedSchema.model_validate(data)
+
+    def list_workspaces(self) -> ResultsResponse[WorkspaceDetailedSchema]:
+        data = self.get("/v1/me/workspaces").json()
+        return ResultsResponse[WorkspaceDetailedSchema].model_validate(data)
+
+    def get_workspace(self) -> WorkspaceDetailedSchema:
+        data = self.get("/v1/workspace").json()
+        return WorkspaceDetailedSchema.model_validate(data)
+
+    def list_projects(self) -> ResultsResponse[ProjectSchema]:
+        data = self.get("/v1/workspace/projects").json()
+        return ResultsResponse[ProjectSchema].model_validate(data)
+
+    def create_project(self, body: CreateProjectBodyDict) -> ProjectSchema:
+        data = self.post("/v1/workspace/projects", json=body).json()
+        return ProjectSchema.model_validate(data)

bevor_cli/commands/agent/materialze_cmd.py

@@ -0,0 +1,65 @@
+"""``bevor analyses scopes materialize``."""
+
+from pathlib import Path
+
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.graph import CallChainBodyDict
+
+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 scopes_materialize() -> None:
+    """Write each scope to ``.bevor/analyses/{analysis_id}/{scope_short_id}.raw.md`` (source + server call-chain text).
+
+    Call chain uses the graph API ``response_type=text``; used to feed skills without re-running graph commands.
+    """
+    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()
+    )
+
+    analysis_source = client.analyses(analysis_id)
+
+    entrypoints = analysis_source.entrypoints()
+    analysis = analysis_source.get()
+
+    if not entrypoints.results:
+        output.warning("No entrypoints for this analysis; nothing to materialize.")
+        return
+
+    node_resource = client.codes.nodes(analysis.version.code_version.id)
+
+    out_root = Path.cwd() / ".bevor" / "analyses" / str(state.analysis_id)
+    out_root.mkdir(parents=True, exist_ok=True)
+
+    for entrypoint in entrypoints.results:
+        if entrypoint.pipeline_status != "failed" and entrypoint.pipeline_status != "queued":
+            # ONLY materialize scopes that should actually be processed.
+            continue
+        if entrypoint.is_analyzed:
+            # ie, it was borrowed, we don't need to materialize it.
+            continue
+
+        source_text = node_resource.content(ID(entrypoint.node.id))
+        call_chain = node_resource.call_chain(
+            CallChainBodyDict(node_ids=[ID(entrypoint.node.id)], response_type="text")
+        )
+        cc_text = str(call_chain) if call_chain else ""
+        path = out_root / f"{entrypoint.node.short_id}.raw.md"
+        path.write_text(
+            f"{source_text}\n\ncall-chain:\n{cc_text}\n",
+            encoding="utf-8",
+        )
+
+    output.success(
+        f"Wrote {len(entrypoints.results)} file(s) under {out_root.relative_to(Path.cwd())!s}/"
+    )

bevor_cli/commands/agent/setup_cmd.py

@@ -0,0 +1,18 @@
+"""``bevor agent setup`` — print the canonical audit-agent workflow."""
+
+from bevor_cli import output
+from bevor_cli.commands.analyses.create import apply_create_analysis
+from bevor_cli.commands.codes.push import push_code
+
+
+def agent_setup() -> None:
+    """Assumes user has ran `bevor link`. After that, running the setup will sync code, generate an
+    analysis, and set the original scopes to first-party only."""
+
+    push_code(yes=True)
+    apply_create_analysis(yes=True)
+
+    output.info(
+        "Code successfully synced, analysis initialized, and scopes set.\n"
+        "Materialize the scopes using `bevor agent materialize`"
+    )

bevor_cli/commands/analyses/active.py

@@ -0,0 +1,42 @@
+"""``bevor analyses recent`` — select your most recent analysis in the selected project."""
+
+import typer
+
+from bevor_cli import output
+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 active_analysis(json_out: JSON_OUT = False) -> None:
+    """Select your most recent analysis in the selected project."""
+
+    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()
+    )
+
+    exists = client.analyses.recent()
+
+    if not exists.exists or not exists.data:
+        output.error(
+            "You have no latest analysis in this project",
+            hint="Run `bevor analyses create` first.",
+        )
+        raise typer.Exit(1)
+
+    analysis = exists.data
+    state.set_analysis(analysis)
+    state.save()
+
+    if json_out:
+        console.print_json(analysis.model_dump_json(indent=2))
+    else:
+        output.success(f"Selected analysis {analysis.id}  ({analysis.name}).")

bevor_cli/commands/analyses/chats/get.py

@@ -0,0 +1,39 @@
+"""``bevor analyses chats get``."""
+
+import typer
+from bevor_sdk.types import ID
+from rich.table import Table
+
+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 get_chat(chat_id: str = typer.Argument(..., help="Chat ID."), json_out: JSON_OUT = False) -> None:
+    """Get the details of 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()
+    )
+    chat = client.chats.get(ID(chat_id))
+
+    if json_out:
+        console.print_json(chat.model_dump_json(indent=2))
+        return
+
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column(style="bold")
+    table.add_column()
+
+    table.add_row("ID", chat.id)
+    table.add_row("Code", str(chat.code_id))
+    if chat.version_id:
+        table.add_row("Version", str(chat.version_id))
+    table.add_row("Created", str(chat.created_at.date()))