bevor-cli 0.1.0__py3-none-any.whl

bevor_cli/commands/analyses/create.py

@@ -0,0 +1,105 @@
+"""``bevor analysis create`` — create a new root analysis."""
+
+from pathlib import Path
+from typing import Literal, Optional
+
+import typer
+from bevor_sdk.helpers.source_fingerprint import zip_source_tree
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.security.analyses import CreateAnalysisRootBodyDict
+from bevor_sdk.types.responses.security import AnalysisCollisionResult, AnalysisCreatedResult
+from rich.prompt import Confirm
+from rich.table import Table
+
+from bevor_cli import output
+from bevor_cli.annotations.confirmations import FORCE, JSON_OUT, YES
+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 apply_create_analysis(
+    *,
+    name: str | None = None,
+    collision: Literal["surface", "force", "merge"] | None = None,
+    force: bool = False,
+    json_out: bool = False,
+    yes: bool = False,
+) -> None:
+    """Create a root analysis for the configured code version. 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()
+
+    if not force:
+        _, _, content_hash = zip_source_tree(Path.cwd())
+        if content_hash != state.code_fingerprint:
+            output.error(
+                "Working directory does not match the configured code fingerprint "
+                "(run `bevor codes push` after your latest changes).",
+                hint="Pass `--force` only if you mean to create without syncing.",
+            )
+            raise typer.Exit(1)
+
+    if not yes:
+        if not Confirm.ask(f"Create new analysis using code {code_id}?"):
+            raise typer.Exit(0)
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+    created = client.analyses.create_root(
+        CreateAnalysisRootBodyDict(code_id=ID(code_id), name=name, on_collision=collision)
+    )
+
+    if isinstance(created, AnalysisCreatedResult):
+        if json_out:
+            console.print_json(created.analysis.model_dump_json(indent=2))
+        else:
+            output.success(
+                f"Analysis created: {created.analysis.id}. "
+                "`bevor analyses run` or `bevor findings add` next."
+            )
+
+        state.set_analysis(created.analysis)
+        state.save()
+    elif isinstance(created, AnalysisCollisionResult):
+        if json_out:
+            console.print_json(created.model_dump_json(indent=2))
+        else:
+            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 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)
+
+
+def create_analysis(
+    name: Optional[str] = typer.Option(None, "--name", help="Optional analysis name."),
+    collision: Optional[Literal["surface", "force", "merge"]] = typer.Option(
+        "surface",
+        "--collision",
+        help="What Bevor should do if analysis already exists for the given code",
+    ),
+    yes: YES = False,
+    json_out: JSON_OUT = False,
+    force: FORCE = False,
+) -> None:
+    """Create a root analysis for the configured code version."""
+    apply_create_analysis(name=name, collision=collision, force=force, yes=yes, json_out=json_out)

bevor_cli/commands/analyses/delete.py

@@ -0,0 +1,65 @@
+"""``bevor analysis delete {full|branch|version}``."""
+
+from typing import Optional
+
+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 delete_analysis_full() -> None:
+    """Delete the entire currently configured analysis container"""
+    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()
+    )
+    client.analyses.delete(analysis_id)
+
+    state.clear_analysis()
+    state.save()
+
+    output.success(f"Deleted analysis {analysis_id}. Cleared analysis from `.bevor`.")
+
+
+def delete_analysis_version(
+    version: Optional[str] = typer.Argument(
+        None,
+        help="Version id to delete (default: configured analysis head).",
+    ),
+) -> None:
+    """Delete a single analysis version (leaf)."""
+    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 not version:
+        analysis_id = state.validate_analysis()
+        analysis = client.analyses.get(analysis_id)
+        id_to_delete = analysis.version.id
+    else:
+        id_to_delete = ID(version)
+
+    result = client.analysis_versions.delete(id_to_delete)
+
+    # HEAD may have moved back to parent — refresh config if still same container.
+    if state.analysis_id == result.id:
+        state.set_analysis(result)
+        state.save()
+
+    output.success(f"Deleted version {id_to_delete}. Updated HEAD to {result.version.id}")

bevor_cli/commands/analyses/diff.py

@@ -0,0 +1,87 @@
+"""``bevor analysis diff``."""
+
+from typing import Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.security import VersionQueryParams
+from bevor_sdk.types.responses.security import FindingBareSchema, FindingTransitionSchema
+from rich.table import Table
+from rich.text import Text
+
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.commands.findings.get import LEVEL_COLORS
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def _snapshot(item: FindingTransitionSchema) -> FindingBareSchema:
+    to_render = item.after_finding or item.before_finding
+    assert to_render
+    return to_render
+
+
+def diff_analysis(
+    version: Optional[str] = typer.Option(
+        None,
+        "--version",
+        help="Version id to diff (default: configured analysis head).",
+    ),
+    staged: bool = typer.Option(
+        False,
+        "--staged",
+        help="Show staged drafts instead of version-vs-parent diffs.",
+    ),
+    json_out: JSON_OUT = False,
+) -> None:
+    """Show finding diffs for the configured analysis head (or ``--version``). --staged flag will show
+    the diff of the staged commits. Excluding it, it'll show the diff of committed findings between the analysis
+    and its parent."""
+    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()
+    )
+
+    opts = VersionQueryParams()
+    if version:
+        v_ = client.analysis_versions.get(ID(version))
+        analysis_id = v_.analysis_meta.id
+        opts["version_id"] = v_.id
+    else:
+        analysis_id = state.validate_analysis()
+
+    analysis_source = client.analyses(analysis_id)
+
+    if staged:
+        page = analysis_source.diff_staged(opts)
+    else:
+        page = analysis_source.diff_version(opts)
+
+    if json_out:
+        console.print_json(page.model_dump_json(indent=2))
+        return
+
+    if not page.results:
+        console.print("No diffs.")
+        return
+
+    table = Table("Reason", "Type", "Level", "Name", "Changed")
+    for item in page.results:
+        snapshot = _snapshot(item)
+
+        table.add_row(
+            item.reason,
+            snapshot.type,
+            Text(snapshot.level, style=LEVEL_COLORS[snapshot.level]),
+            snapshot.name,
+            ", ".join(item.changed_fields),
+        )
+
+    console.print(table)

bevor_cli/commands/analyses/entrypoints.py

@@ -0,0 +1,56 @@
+"""``bevor analysis entrypoints``."""
+
+import json
+from typing import Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.security import VersionQueryParams
+
+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_entrypoints(
+    version: Optional[str] = typer.Option(
+        None,
+        "--version",
+        help="Version id (default: configured analysis head).",
+    ),
+    json_out: JSON_OUT = False,
+) -> None:
+    """List entrypoints for the configured analysis head (or ``--version``)."""
+    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()
+    )
+
+    opts = VersionQueryParams()
+    if version:
+        v_ = client.analysis_versions.get(ID(version))
+        analysis_id = v_.analysis_meta.id
+        version_id = v_.id
+        opts["version_id"] = version_id
+    else:
+        analysis_id = state.validate_analysis()
+
+    page = client.analyses.entrypoints(analysis_id, opts)
+
+    if json_out:
+        console.print_json(json.dumps(page.model_dump(mode="json"), indent=2))
+        return
+
+    if not page.results:
+        console.print("No scopes.")
+        return
+
+    for s in page.results:
+        console.print(f"{s.node.short_id}  {s.node.name}  ({s.node.path})  [{s.pipeline_status}]")

bevor_cli/commands/analyses/findings.py

@@ -0,0 +1,129 @@
+"""``bevor finding list``."""
+
+import json
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from bevor_sdk import Graph
+from bevor_sdk.helpers.converters.sarif import bevor_to_sarif_sync
+from bevor_sdk.types import ID
+from bevor_sdk.types.literals import FindingDraftOperation, FindingLevel, FindingType
+from bevor_sdk.types.requests.security import VersionQueryParams
+from bevor_sdk.types.responses.security import FindingSchema
+
+from bevor_cli import output
+from bevor_cli.annotations.confirmations import JSON_OUT
+from bevor_cli.client import BevorInternalClient
+from bevor_cli.commands.findings.interactive import (
+    browse_findings_with_actions,
+    print_findings_table_with_ops,
+)
+from bevor_cli.configuration.creds import Credentials
+from bevor_cli.configuration.state import State
+from bevor_cli.output import console
+
+
+def _on_node(finding: FindingSchema, node_id: Optional[str]) -> bool:
+    if not node_id:
+        return True
+    if str(finding.node_id) == node_id:
+        return True
+    return finding.location_id is not None and str(finding.location_id) == node_id
+
+
+def _matches(
+    finding: FindingSchema,
+    *,
+    finding_type: Optional[FindingType],
+    level: Optional[FindingLevel],
+    is_acknowledged: Optional[bool],
+    operation: Optional[FindingDraftOperation],
+    created_by: Optional[str],
+    node_id: Optional[str],
+) -> bool:
+    """Filters the version findings endpoint does not support server-side."""
+    if finding_type and finding.type != finding_type:
+        return False
+    if level and finding.level != level:
+        return False
+    if is_acknowledged is not None and finding.is_acknowledged is not is_acknowledged:
+        return False
+    if operation and finding.operation != operation:
+        return False
+    if created_by and str(finding.created_by_user.id) != created_by:
+        return False
+    return _on_node(finding, node_id)
+
+
+def list_analysis_findings(
+    version: Optional[str] = typer.Option(
+        None,
+        "--version",
+        help="Version id to list findings for (default: configured analysis head).",
+    ),
+    interactive: bool = typer.Option(
+        False, "--interactive", help="Browse findings and expand the focused row."
+    ),
+    json_out: JSON_OUT = False,
+    sarif: Optional[Path] = typer.Option(
+        None, "--sarif", help="Write SARIF for the configured analysis to this path."
+    ),
+) -> None:
+    """List findings on the configured analysis, or ``--version``. Including a --sarif path will output
+    the findings into a SARIF format. --interactive will open an interactive terminal to explore further."""
+    creds = Credentials.load()
+    creds.require_token()
+
+    state = State.load()
+    workspace_id = state.validate_workspace()
+
+    if sarif and not sarif.parent.exists():
+        output.error(
+            f"Directory does not exist: {sarif.parent}",
+            hint="Create it first, or pass a different --sarif path.",
+        )
+        raise typer.Exit(1)
+
+    client = BevorInternalClient(
+        creds=creds, workspace_id=workspace_id, project_id=state.validate_project()
+    )
+
+    opts = VersionQueryParams()
+    if version:
+        v_ = client.analysis_versions.get(ID(version))
+        analysis_id = v_.analysis_meta.id
+        version_id = v_.id
+        opts["version_id"] = version_id
+    else:
+        analysis_id = state.validate_analysis()
+
+    result = client.analyses.list_findings(analysis_id, options=opts)
+
+    if json_out:
+        console.print_json(json.dumps([f.model_dump(mode="json") for f in result.results], indent=2))
+        return
+
+    if sarif:
+        analysis = client.analyses.get(analysis_id)
+        code_id = analysis.version.code_version.id
+
+        graph = Graph(client=client, code_id=code_id)
+        graph.build()
+
+        sarif_schema = bevor_to_sarif_sync(graph=graph, findings=result.results)
+        sarif.write_text(sarif_schema.model_dump_json(indent=2, exclude_none=True))
+        output.success(f"Wrote sarif outputs to {sarif.name}")
+        return
+
+    if not result.results:
+        console.print("No findings.")
+        return
+
+    def refetch() -> List[FindingSchema]:
+        return client.analyses.list_findings(analysis_id, options=opts).results
+
+    if interactive:
+        browse_findings_with_actions(client=client, refetch=refetch, rows=result.results)
+    else:
+        print_findings_table_with_ops(result.results)

bevor_cli/commands/analyses/fork.py

@@ -0,0 +1,47 @@
+"""``bevor analysis fork``."""
+
+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 fork_analysis(
+    version: Optional[str] = typer.Option(
+        None,
+        "--version",
+        help="Version id to fork (default: configured analysis head).",
+    ),
+) -> None:
+    """Fork an analysis version and set the new analysis as configured."""
+    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()
+    )
+
+    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()
+
+    created = client.analyses.fork(analysis_id, body)
+
+    state.set_analysis(created)
+    state.save()
+
+    output.success(f"Forked to analysis {created.id}. Active analysis updated in `.bevor`.")

bevor_cli/commands/analyses/list.py

@@ -0,0 +1,85 @@
+"""``bevor analyses list``."""
+
+import json
+from typing import Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.security import AnalysesQueryParams
+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, info
+
+
+def list_analyses(
+    page: PAGE = None,
+    page_size: PAGE_SIZE = None,
+    order: ORDER = None,
+    order_by: ORDER_BY = None,
+    project: Optional[str] = typer.Option(
+        None,
+        "--project",
+        help="Project ID (defaults to .bevor config).",
+    ),
+    user: Optional[str] = typer.Option(None, "--user", help="Analysis creator to filter by"),
+    is_owner: Optional[bool] = typer.Option(None, "--is-owner", help="Analysis filter by owner only"),
+    json_out: JSON_OUT = False,
+) -> None:
+    """List analyses for the configured project, or use the --project flag to list for a specific 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 = AnalysesQueryParams()
+    if page:
+        query_params["page"] = page
+    query_params["page_size"] = page_size or settings.default_page_size
+    if order:
+        query_params["order"] = order
+    if order_by:
+        query_params["order_by"] = order_by
+    if user:
+        query_params["user_id"] = ID(user)
+    if is_owner:
+        query_params["is_owner"] = is_owner
+
+    analyses = client.analyses.list(query_params)
+
+    if not analyses.results:
+        console.print("No analyses found.")
+        return
+
+    if json_out:
+        console.print_json(
+            json.dumps([a.model_dump(mode="json") for a in analyses.results], indent=2)
+        )
+        return
+
+    table = Table("ID", "Name", "Code", "Owner", "Created")
+    for a in analyses.results:
+        args = [a.id, a.name, a.version.code_version.id, a.user.username, str(a.created_at.date())]
+        if a.id == state.analysis_id:
+            args.append("●")
+
+        table.add_row(*args)
+
+    console.print(table)
+
+    if analyses.more:
+        info(
+            f"\nShowing {len(analyses.results)} of {analyses.total_observations} results. Use --page --page-size to navigate."
+        )

bevor_cli/commands/analyses/merge.py

@@ -0,0 +1,46 @@
+"""``bevor analysis merge``."""
+
+from typing import Optional
+
+import typer
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.security import MergeAnalysisBodyDict
+
+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 merge_analysis(
+    from_analysis: str = typer.Argument(..., help="Source analysis container id."),
+    to_analysis: Optional[str] = typer.Option(
+        None, "--to", help="Destination analysis container id."
+    ),
+) -> None:
+    """Merge one analysis into another. --from is required, but --to defaults to your active analysis's HEAD.
+    This will create a child analysis version of the --to, and update its HEAD."""
+    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()
+    )
+
+    from_ = client.analyses.get(ID(from_analysis))
+
+    to_analysis_id = state.validate_analysis(priority=to_analysis)
+    to_ = client.analyses.get(to_analysis_id)
+
+    created = client.analyses.merge(
+        MergeAnalysisBodyDict(to_version_id=to_.version.id, from_version_id=from_.version.id)
+    )
+
+    state.set_analysis(created)
+    state.save()
+
+    output.success(
+        f"Merge complete → analysis {created.id} head {created.version.id}. Config updated."
+    )