bevor-cli 0.1.0__py3-none-any.whl

bevor_cli/commands/findings/list.py

@@ -0,0 +1,108 @@
+"""``bevor finding list``."""
+
+from typing import Annotated, Literal, Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.literals import FindingDraftOperation, FindingLevel, FindingType
+from bevor_sdk.types.requests.security import FindingsQueryParams
+
+from bevor_cli import output
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.annotations.query import ORDER, PAGE, PAGE_SIZE
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.commands.findings.interactive import (
+    print_findings_table_with_ops,
+)
+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_findings(
+    page: PAGE = None,
+    page_size: PAGE_SIZE = None,
+    order: ORDER = None,
+    order_by: Annotated[
+        Literal["created_at", "updated_at", "level"] | None,
+        typer.Option(
+            "--order-by", help="What field to order results by when a resource supports pagination"
+        ),
+    ] = None,
+    project_id: Optional[str] = typer.Option(None, "--project", help="Project id to search (defaults to configured project)."),
+    is_self: Optional[bool] = typer.Option(
+        None, "--self", help="Filter by findings in analyses the caller owns."
+    ),
+    user_id: Optional[str] = typer.Option(
+        None, "--user", help="Filter by user id (user who owns the analysis the finding is in)"
+    ),
+    code_id: Optional[str] = typer.Option(None, "--code", help="Code Id to filter by."),
+    analysis_ids: Optional[str] = typer.Option(
+        None, "--analyses", help="Analysis ids to filter by (comma separated)"
+    ),
+    finding_type: Optional[FindingType] = typer.Option(None, "--type", help="Finding type."),
+    level: Optional[FindingLevel] = typer.Option(None, "--level", help="Finding level."),
+    is_acknowledged: Optional[bool] = typer.Option(
+        None, "--acknowledged", help="Filter by acknowledgement status."
+    ),
+    operation: Optional[FindingDraftOperation] = typer.Option(
+        None, "--operation", help="Staged draft operation."
+    ),
+    created_by_self: Optional[bool] = typer.Option(
+        None, "--created-by-self", help="Filter by findings the caller is original creator of"
+    ),
+    created_by_user_id: Optional[str] = typer.Option(
+        None, "--created-by", help="Filter by original creator of a finding."
+    ),
+    json_out: JSON_OUT = False,
+) -> None:
+    """Search findings across the currently configured project, or the --project."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    settings = Settings.load()
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project(priority=project_id)
+    )
+
+    query_params = FindingsQueryParams(
+        page=page,
+        page_size=page_size or settings.default_page_size,
+        order=order,
+        order_by=order_by,
+        type=finding_type,
+        level=level,
+        is_acknowledged=is_acknowledged,
+        operation=operation,
+    )
+    if is_self is not None:
+        query_params["is_self"] = is_self
+    elif user_id:
+        query_params["user_id"] = ID(user_id)
+    if code_id:
+        query_params["code_id"] = ID(code_id)
+    if analysis_ids:
+        query_params["analysis_ids"] = [ID(aid.strip()) for aid in analysis_ids.split(",")]
+    if created_by_self is not None:
+        query_params["created_by_self"] = created_by_self
+    elif created_by_user_id:
+        query_params["created_by_user_id"] = ID(created_by_user_id)
+
+    found = client.findings.list(query_params)
+
+    if json_out:
+        console.print_json(found.model_dump_json(indent=2))
+        return
+
+    if not found.results:
+        console.print("No findings.")
+        return
+
+    print_findings_table_with_ops(found.results)
+
+    if found.more:
+        output.info(f"\nShowing {found.page} of {found.total_pages}. Increase with --page-size/-n.")

bevor_cli/commands/findings/revert.py

@@ -0,0 +1,28 @@
+"""``bevor findings revert``."""
+
+import typer
+from bevor_sdk.types import ID
+
+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 revert_finding(
+    finding_id: str = typer.Argument(..., help="Finding id to revert."),
+) -> None:
+    """Revert a staged finding change."""
+    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()
+    )
+
+    client.findings.revert(ID(finding_id))
+
+    output.success("Finding reverted.")

bevor_cli/commands/graph/call_chain.py

@@ -0,0 +1,48 @@
+"""Call-chain command (mounted at ``bevor code node call-chain``)."""
+
+import json
+from typing import Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.graph import CallChainBodyDict
+
+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
+
+from .renderer import build_call_chain_rich_tree
+
+
+def call_chain_cmd(
+    node_id: str = typer.Argument(..., help="Node id"),
+    code_id: Optional[str] = typer.Option(
+        None, "--code", help="Code id to list for  (defaults to current configuration)"
+    ),
+    json_out: JSON_OUT = False,
+) -> None:
+    """Get the call chain for a given node. Uses the currently configured code version, or you can pass --code."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    code_id = state.validate_code(priority=code_id)
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    call_chain = client.codes.nodes.call_chain(
+        code_id,
+        CallChainBodyDict(node_ids=[ID(node_id)], response_type="json"),
+    )
+
+    if not call_chain.results:
+        console.print("[dim]Empty call chain.[/dim]")
+    elif json_out:
+        console.print_json(json.dumps(call_chain.results[0].call_chain, indent=2))
+    else:
+        console.print(build_call_chain_rich_tree(call_chain.results[0], label=node_id))

bevor_cli/commands/graph/edges.py

@@ -0,0 +1,59 @@
+"""Edges list (mounted at ``bevor code node edges``)."""
+
+import json
+from typing import Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.literals import EdgeDirection, EdgeType
+from bevor_sdk.types.requests.graph import EdgeQueryParams
+
+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 list_node_edges(
+    node_id: str = typer.Argument(..., help="Node short id or full wire id."),
+    code_id: Optional[str] = typer.Option(
+        None, "--code", help="Code id to list for  (defaults to current configuration)"
+    ),
+    direction: Optional[EdgeDirection] = typer.Option(
+        None,
+        "--direction",
+        help="Edge direction filter: in, out.",
+    ),
+    edge_type: Optional[EdgeType] = typer.Option(
+        None,
+        "--type",
+        help="Edge type (e.g. calls, defines).",
+    ),
+    json_out: JSON_OUT = False,
+) -> None:
+    """List the edges for a given node. Uses the currently configured code version, or you can pass --code."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    code_id = state.validate_code(priority=code_id)
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    res = client.codes.nodes.edges(
+        code_id, ID(node_id), EdgeQueryParams(edge_type=edge_type, direction=direction)
+    )
+
+    if not res.results:
+        console.print("No edges.")
+        return
+
+    if json_out:
+        console.print_json(res.model_dump_json(indent=2))
+        return
+
+    console.print_json(json.dumps([e.model_dump(mode="json") for e in res.results], indent=2))

bevor_cli/commands/graph/interactive.py

@@ -0,0 +1,207 @@
+"""``bevor code node interactive`` — browse from a node with get / source / call-chain / edges."""
+
+from __future__ import annotations
+
+from typing import Optional, cast
+
+import questionary
+import typer
+from bevor_sdk._shared import CallNode
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.graph import CallChainBodyDict
+from bevor_sdk.types.responses.graph import GraphSnapshotEdge, GraphSnapshotNode
+from rich.syntax import Syntax
+
+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
+from bevor_cli.select import _CANCEL
+
+from .renderer import build_call_chain_rich_tree, call_chain_nav_choices
+
+_MENU_STYLE = questionary.Style(
+    [
+        ("highlighted", "bold"),
+        ("selected", "bold fg:ansibrightyellow"),
+        ("instruction", "fg:ansibrightblack italic"),
+        ("pointer", "bold fg:ansibrightyellow"),
+    ]
+)
+
+
+def _other_endpoint(self_full_id: str, e: GraphSnapshotEdge) -> str:
+    s, d = str(e.src_id), str(e.dst_id)
+    if s == self_full_id:
+        return d
+    if d == self_full_id:
+        return s
+    return d
+
+
+def _select_jump(
+    message: str,
+    pairs: list[tuple[str, str]],
+) -> str | None:
+    """Return chosen node ref, or None for cancel / stay."""
+    if not pairs:
+        return None
+    choices: list = [questionary.Choice(title=label, value=ref) for ref, label in pairs]
+    choices.append(questionary.Choice(title="↵ Stay on current node", value=_CANCEL))
+    r = questionary.select(
+        message,
+        choices=choices,
+        use_jk_keys=True,
+        style=_MENU_STYLE,
+        instruction="(↑↓/j/k · Enter)",
+    ).ask()
+    if r is None or r is _CANCEL:
+        return None
+    return str(r)
+
+
+def _main_action(
+    node: GraphSnapshotNode,
+    *,
+    can_back: bool,
+) -> str | None:
+    choices: list[questionary.Choice] = [
+        questionary.Choice("Get — show metadata", value="g"),
+        questionary.Choice("Source — show code content", value="s"),
+    ]
+    if node.is_callable:
+        choices.append(
+            questionary.Choice("Call chain — tree, then pick a node to jump to", value="c")
+        )
+    choices.append(
+        questionary.Choice("Edges — list edges, then pick a neighbor to jump to", value="e")
+    )
+    if can_back:
+        choices.append(questionary.Choice("Back — previous node", value="b"))
+    choices.append(questionary.Choice("Quit", value="q"))
+    r = questionary.select(
+        f"{node.short_id}  {node.name}  —  action",
+        choices=choices,
+        style=_MENU_STYLE,
+        instruction="(↑↓/j/k · Enter)",
+    ).ask()
+    if r is None:
+        return "q"
+    return cast(str, r)
+
+
+def interactive_cmd(
+    node_id: str = typer.Argument(..., help="Node to start from (short id or full id)."),
+    code_id: Optional[str] = typer.Option(
+        None, "--code", help="Code id to list for  (defaults to current configuration)"
+    ),
+) -> None:
+    """Explore the graph from a node: get, source, optional call-chain (callable nodes only), and edges.
+    Uses the currently configured code version, or you can pass --code.
+    """
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+    code_id = state.validate_code(priority=code_id)
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    current = node_id
+    back_stack: list[str] = []
+
+    while True:
+        with output.spinner(f"Loading node {current}…"):
+            try:
+                node = client.codes.nodes.get(code_id, ID(current))
+            except Exception as exc:
+                output.error(f"Could not load node {current!r}: {exc}")
+                raise typer.Exit(1) from exc
+
+        action = _main_action(node, can_back=bool(back_stack))
+        if action is None or action == "q":
+            return
+        if action == "b":
+            if not back_stack:
+                continue
+            current = back_stack.pop()
+            continue
+
+        if action == "g":
+            typer.echo(f"ID:        {node.id}")
+            typer.echo(f"Short id:  {node.short_id}")
+            typer.echo(f"Name:      {node.name}")
+            typer.echo(f"Type:      {node.node_type}")
+            typer.echo(f"File:      {node.path} ({node.file_id})")
+        elif action == "s":
+            with output.spinner(f"Fetching source for {node.short_id}…"):
+                content = client.codes.nodes.content(code_id, ID(node.short_id))
+            if not content:
+                output.error("No source content available.")
+            else:
+                console.print(
+                    Syntax(
+                        content.strip(), "solidity", theme="monokai", line_numbers=False, padding=1
+                    )
+                )
+        elif action == "c":
+            if not node.is_callable:
+                output.error("Call chain is only available for callable nodes.")
+                continue
+            data = client.codes.nodes.call_chain(
+                code_id,
+                CallChainBodyDict(node_ids=[ID(node.short_id)], response_type="json"),
+            )
+            if not data.results:
+                console.print("[dim]Empty call chain.[/dim]")
+                return
+
+            console.print(build_call_chain_rich_tree(data.results[0], label=node_id))
+            root = CallNode.from_dict(cast(dict, data.results[0].call_chain))
+            pairs = (
+                call_chain_nav_choices(
+                    root,
+                    skip_short_id=str(node.short_id),
+                    skip_full_id=str(node.id),
+                )
+                if root
+                else []
+            )
+            if pairs:
+                picked = _select_jump("Jump to which node? (or stay)", pairs)
+                if picked:
+                    back_stack.append(current)
+                    current = picked
+            else:
+                typer.echo("No other nodes in this call chain to jump to.")
+        elif action == "e":
+            with output.spinner("Fetching edges…"):
+                res = client.codes.nodes.edges(code_id, ID(node.short_id))
+            self_id = str(node.id)
+            rows: list[GraphSnapshotEdge] = list(res.results)
+            if not rows:
+                typer.echo("No edges.")
+            else:
+                labels: list[tuple[str, str]] = []
+                with output.spinner("Resolving edge endpoints…"):
+                    for e in rows:
+                        other = _other_endpoint(self_id, e)
+                        nbr = client.codes.nodes.get(code_id, ID(other))
+                        way = e.direction if e.direction else "—"
+                        labels.append(
+                            (
+                                nbr.short_id,
+                                f"{e.edge_type}  {way}  {nbr.name}  [{nbr.short_id}]",
+                            )
+                        )
+                picked = _select_jump("Jump to which neighbor? (or stay)", labels)
+                if picked:
+                    back_stack.append(current)
+                    current = picked
+        else:
+            output.error(f"Unknown action: {action!r}")
+            raise typer.Exit(1)

bevor_cli/commands/graph/renderer.py

@@ -0,0 +1,135 @@
+"""Rich tree rendering for call-chain JSON (CLI-only)."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from bevor_sdk._shared import CallNode
+from bevor_sdk.helpers.call_chain.enrich_impl import (
+    _format_line,
+    callable_display_parts,
+    format_resolved_storage_access_line,
+)
+from bevor_sdk.types.responses.graph import CallChainSchema
+from rich.markup import escape as rich_escape
+from rich.tree import Tree
+
+_EDGE_COLORS = {
+    "calls": "green",
+    "calls_external": "yellow",
+    "reads": "blue",
+    "writes": "red",
+    "uses": "cyan",
+    "initializes": "magenta",
+}
+
+
+def _rich_headline(cn: CallNode, parent: CallNode | None) -> str:
+    nm, sid = callable_display_parts(cn)
+    if cn.is_cyclic:
+        if sid:
+            return f"[bold red][CYCLIC][/bold red] {rich_escape(nm)} [{rich_escape(sid)}]"
+        return f"[bold red][CYCLIC][/bold red] {rich_escape(nm)}"
+    plain = _format_line(cn, parent)
+    et = cn.edge_type
+    if et:
+        c = _EDGE_COLORS.get(str(et), "white")
+        marker = f" {nm} ["
+        i = plain.find(marker)
+        if i >= 0:
+            prefix, rest = plain[:i], plain[i + 1 :]
+            return f"[{c}]{rich_escape(prefix)}[/{c}] {rich_escape(rest)}"
+    return rich_escape(plain)
+
+
+def _append_resolved_bindings(parent: Tree, cn: CallNode) -> None:
+    binds = cn.resolved_bindings
+    if not binds:
+        return
+    inject = parent.add("[dim]injected from parent call[/dim]")
+    for a in sorted(binds, key=lambda x: x.start_byte):
+        inject.add(rich_escape(format_resolved_storage_access_line(a)))
+
+
+def _append_branch(
+    parent: Tree,
+    cn: CallNode,
+    *,
+    depth: int = 0,
+) -> None:
+    if cn.is_cyclic:
+        return
+
+    _append_resolved_bindings(parent, cn)
+
+    children = cn.children
+    arg_children = [ch for ch in children if ch.is_arg]
+    non_arg_children = [ch for ch in children if not ch.is_arg]
+    if arg_children:
+        args_branch = parent.add("[dim]args[/dim]")
+        for ch in arg_children:
+            sub = args_branch.add(_rich_headline(ch, cn))
+            _append_branch(sub, ch, depth=depth + 2)
+    for ch in non_arg_children:
+        sub = parent.add(_rich_headline(ch, cn))
+        _append_branch(sub, ch, depth=depth + 1)
+
+
+def build_call_chain_rich_tree(root: CallChainSchema, label: str = "call chain") -> Tree:
+    """Build a :class:`rich.tree.Tree` for a deserialized call chain."""
+    call_node = CallNode.from_dict(cast(dict, root.call_chain))
+
+    _, root_sid = callable_display_parts(call_node)
+    first_ref = str(root.short_id or call_node.edge_id or root_sid)
+    body = _rich_headline(call_node, None)
+    if label and first_ref and str(label) == first_ref:
+        root_label = f"[bold]{body}[/bold]"
+    else:
+        root_label = f"[bold]{body}[/bold]  [dim]{rich_escape(str(label))}[/dim]"
+    tree = Tree(root_label)
+    _append_branch(tree, call_node, depth=0)
+    return tree
+
+
+def call_chain_nav_choices(
+    root: CallNode,
+    *,
+    skip_short_id: str | None = None,
+    skip_full_id: str | None = None,
+) -> list[tuple[str, str]]:
+    """Unique ``(short_id, label)`` pairs in the same visit order as :meth:`CallNode.to_text`."""
+    seen: set[str] = set()
+    out: list[tuple[str, str]] = []
+
+    def maybe_add(cn: CallNode) -> None:
+        nm, bracket = callable_display_parts(cn)
+        full = str(cn.node_id or "")
+        if skip_short_id and cn.short_id == skip_short_id:
+            return
+        if skip_full_id and full and full == skip_full_id:
+            return
+        key = f"{cn.short_id or ''}|{cn.edge_id or ''}|{cn.node_id or ''}"
+        if key in seen:
+            return
+        seen.add(key)
+        ref = str(cn.short_id or cn.edge_id or bracket)
+        et = cn.edge_type
+        if et:
+            lab = f"{et}  {nm}  [{ref[:12]}]"
+        else:
+            lab = f"{nm}  [{ref[:12]}]"
+        out.append((ref, lab))
+
+    def visit(cn: CallNode) -> None:
+        maybe_add(cn)
+        if cn.is_cyclic:
+            return
+        arg_children = [ch for ch in cn.children if ch.is_arg]
+        non_arg_children = [ch for ch in cn.children if not ch.is_arg]
+        for ch in arg_children:
+            visit(ch)
+        for ch in non_arg_children:
+            visit(ch)
+
+    visit(root)
+    return out

bevor_cli/commands/link/__init__.py

@@ -0,0 +1,52 @@
+"""bevor link — link the current directory to a Bevor project."""
+
+from bevor_sdk.types.responses.manage import ProjectSchema
+
+from bevor_cli import output
+from bevor_cli.client import BevorInternalBusinessClient
+from bevor_cli.commands.link.helpers import pick_project
+from bevor_cli.commands.workspaces.pick import pick_workspace
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+
+
+def run_link() -> None:
+    """Link the current directory to a Bevor workspace and project.
+
+    Resets/creates the .bevor/config.json.
+    """
+
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+
+    workspaces = BevorInternalBusinessClient(creds=creds).list_workspaces()
+
+    resolved_workspace = pick_workspace(workspaces.results)
+
+    state.set_workspace(workspace_id=resolved_workspace.id)
+
+    # incrementally write this.
+    state.save()
+
+    client = BevorInternalBusinessClient(creds=creds, workspace_id=resolved_workspace.id)
+    projects = client.list_projects()
+
+    resolved_project: ProjectSchema | None = None
+    if projects.results:
+        resolved_project = pick_project(projects.results)
+        state.set_project(project_id=resolved_project.id)
+
+    state.save()
+
+    output.success("Linked.")
+    output.info(f"  Workspace : {resolved_workspace.id}")
+    if resolved_project:
+        output.info(f"  Project   : {resolved_project.id}")
+    else:
+        output.info("  Project   : (not set)")
+    output.info("\nNext steps:")
+    output.info("  bevor codes push          # upload current directory as a code version")
+    output.info("  bevor analyses create     # run analysis on the uploaded code")
+    output.info("  bevor codes nodes list    # explore the code graph")

bevor_cli/commands/link/helpers.py

@@ -0,0 +1,26 @@
+"""Helpers for ``bevor link``."""
+
+from typing import List, Literal
+
+import questionary
+import typer
+from bevor_sdk.types.responses.manage import ProjectSchema
+
+from bevor_cli.commands.projects.create import create_project
+from bevor_cli.select import _select
+
+
+def pick_project(projects: List[ProjectSchema]) -> ProjectSchema:
+    """Interactively choose an existing project or create a new one."""
+
+    choices = [questionary.Choice(title=f"{p.name}  {p.id}", value=p) for p in projects]
+    choices.append(questionary.Choice(title="+ Create a new project", value="__new__"))
+
+    chosen: ProjectSchema | None | Literal["__new__"] = _select(
+        "Select a project (or create new):", choices
+    )
+    if chosen is None:
+        raise typer.Exit(0)
+    if chosen == "__new__":
+        return create_project(name=None, description=None)
+    return chosen