vidbyte-cli 0.1.0__py3-none-any.whl

vidbyte_cli/lib/io/terminal.py

@@ -0,0 +1,66 @@
+"""What this invocation's terminal can safely be asked to do.
+
+Capabilities are data, detected once from injected streams and an injected environment.
+Injecting both is what makes redirection, CI, embedding, and Windows consoles predictable
+instead of depending on process globals. No escape sequence is ever written from here.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import TextIO
+
+from ..output.formats import ColorMode
+from .streams import IOStreams
+
+
+@dataclass(frozen=True)
+class TerminalPolicy:
+    """Preferences and environment used for one capability decision."""
+
+    color: ColorMode = ColorMode.AUTO
+    no_input: bool = False
+    environment: Mapping[str, str] | None = None
+
+
+@dataclass(frozen=True)
+class TerminalCapabilities:
+    """Terminal features safe to use for one invocation."""
+
+    interactive: bool
+    color: bool
+    cursor: bool
+
+    @classmethod
+    def detect(cls, streams: IOStreams, policy: TerminalPolicy) -> TerminalCapabilities:
+        # Environment injection avoids hiding global reads inside renderers.
+        environment = os.environ if policy.environment is None else policy.environment
+        terminal_allowed = cls._terminal_control_allowed(cls._is_tty(streams.stderr), environment)
+        return cls(
+            interactive=cls._is_tty(streams.stdin) and not policy.no_input,
+            color=terminal_allowed and policy.color is not ColorMode.NEVER,
+            cursor=terminal_allowed,
+        )
+
+    @staticmethod
+    def _is_tty(stream: TextIO) -> bool:
+        # Redirected and in-memory streams may expose no usable isatty implementation.
+        isatty = getattr(stream, "isatty", None)
+        if not callable(isatty):
+            return False
+        try:
+            return bool(isatty())
+        except (OSError, ValueError):
+            return False
+
+    @staticmethod
+    def _terminal_control_allowed(stderr_tty: bool, environment: Mapping[str, str]) -> bool:
+        # Accessibility and shell safety outrank an explicit color request: even
+        # `--color always` cannot turn on control sequences here.
+        if not stderr_tty:
+            return False
+        if environment.get("TERM", "").lower() == "dumb":
+            return False
+        return "NO_COLOR" not in environment

vidbyte_cli/lib/output/__init__.py

@@ -0,0 +1,7 @@
+"""Public presentation contracts. Feature presenters stay private to their own slices."""
+
+from .formats import ColorMode, OutputFormat
+from .manager import OutputManager, OutputPolicy
+from .models import OutputDocument
+
+__all__ = ["ColorMode", "OutputDocument", "OutputFormat", "OutputManager", "OutputPolicy"]

vidbyte_cli/lib/output/formats.py

@@ -0,0 +1,29 @@
+"""The root presentation vocabulary shared by flags, terminal detection, and rendering.
+
+String enums keep Click choices, config values, and diagnostics on one set of spellings.
+Nothing here inspects a TTY or serializes a document — `lib/io` owns capability detection
+and `manager.py` owns stream policy.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class OutputFormat(StrEnum):
+    """Supported result serialization modes."""
+
+    HUMAN = "human"
+    JSON = "json"
+    JSONL = "jsonl"
+    NONE = "none"
+
+
+class ColorMode(StrEnum):
+    """User preference for terminal color when the stream permits it."""
+
+    # ALWAYS is still subject to the accessibility rule: a redirected stream, TERM=dumb, or
+    # NO_COLOR disables terminal control regardless of what was requested.
+    AUTO = "auto"
+    ALWAYS = "always"
+    NEVER = "never"

vidbyte_cli/lib/output/manager.py

@@ -0,0 +1,95 @@
+"""Where results, progress, warnings, and failures are allowed to go, for one invocation.
+
+Two rules make this file worth existing. Stdout carries results only, so a shell pipeline
+stays parseable while progress and diagnostics run on stderr. And a machine format never
+silently degrades to human text — a consumer that asked for JSON gets JSON or an error.
+
+Human error text repeats the agent-native description/trace/file_path that machine documents
+carry, because agents shell out to the default format far more often than they pass --json.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Protocol
+
+from .formats import OutputFormat
+from .models import OutputDocument
+
+if TYPE_CHECKING:
+    from ..errors.cli_error import CliError
+    from ..io.terminal import TerminalCapabilities
+
+
+class OutputStreams(Protocol):
+    """Minimum physical stream behavior required by output policy."""
+
+    def write_output(self, message: str) -> None: ...
+
+    def write_error(self, message: str) -> None: ...
+
+
+@dataclass(frozen=True)
+class OutputPolicy:
+    """Presentation choices used by one output manager."""
+
+    output_format: OutputFormat
+    terminal: TerminalCapabilities
+
+
+class OutputManager:
+    """Invocation-owned presentation and stream policy."""
+
+    def __init__(self, streams: OutputStreams, policy: OutputPolicy) -> None:
+        self._streams = streams
+        self.format = policy.output_format
+        self.terminal = policy.terminal
+
+    def result(self, document: OutputDocument, human: str) -> None:
+        # JSON and JSONL both emit one record here; only JSONL may emit earlier transitions.
+        if self.format is OutputFormat.NONE:
+            return
+        if self.format is OutputFormat.HUMAN:
+            self._streams.write_output(human)
+            return
+        self._streams.write_output(self._serialize(document))
+
+    def transition(self, document: OutputDocument, human: str) -> None:
+        # A single-JSON consumer must see exactly one final stdout document.
+        if self.format is OutputFormat.JSONL:
+            self._streams.write_output(self._serialize(document))
+        elif self.format is OutputFormat.HUMAN:
+            self._streams.write_error(human)
+
+    def warning(self, message: str) -> None:
+        # Warnings stay visible in every format without corrupting structured stdout.
+        self._streams.write_error(f"Warning: {message}")
+
+    def diagnostic(self, message: str) -> None:
+        # Debug and verbose details are diagnostics, never command results.
+        self._streams.write_error(message)
+
+    def error(self, error: CliError) -> None:
+        # NONE suppresses ordinary output, not actionable failures.
+        if self.format in {OutputFormat.JSON, OutputFormat.JSONL}:
+            self._streams.write_error(self._serialize(OutputDocument.from_error(error)))
+            return
+        self._streams.write_error(self._human_error(error))
+
+    def _serialize(self, document: OutputDocument) -> str:
+        # Pydantic owns strict JSON encoding; failures propagate as internal software errors.
+        return document.model_dump_json(exclude_none=True)
+
+    def _human_error(self, error: CliError) -> str:
+        # Text labels preserve meaning when color and cursor control are unavailable.
+        lines = [
+            f"Error [{error.code.value}]: {error.message}",
+            f"Details: {error.description}",
+            f"Trace: {error.trace}",
+            f"Source: {error.file_path}",
+        ]
+        if error.hint is not None:
+            lines.append(f"Hint: {error.hint}")
+        if error.request_id is not None:
+            lines.append(f"Request ID: {error.request_id}")
+        return "\n".join(lines)

vidbyte_cli/lib/output/models.py

@@ -0,0 +1,49 @@
+"""The versioned envelope every machine-readable record travels in.
+
+`schema_version` and `kind` are the compatibility contract: a consumer branches on them and
+finds its own keys under `data`. Fields may be added, never removed or repurposed.
+
+`CliError` is imported for typing only. A runtime import would cycle, because the errors
+package imports the output manager to render failures.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, JsonValue
+
+if TYPE_CHECKING:
+    from ..errors.cli_error import CliError
+
+
+class OutputDocument(BaseModel):
+    """One stable result, transition, or error record."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    schema_version: Literal[1] = 1
+    kind: str = Field(min_length=1, pattern=r"^[a-z][a-z0-9_.-]*$")
+    data: dict[str, JsonValue] = Field(default_factory=dict)
+
+    @classmethod
+    def from_error(cls, error: CliError) -> OutputDocument:
+        # Only explicitly safe fields cross this boundary; the private cause never does.
+        # Optional fields are omitted rather than emitted as null so a shell consumer can
+        # tell absent metadata from a deliberate value.
+        data: dict[str, JsonValue] = {
+            "code": error.code_value,
+            "message": error.message,
+            "description": error.description,
+            "trace": error.trace,
+            "file_path": error.file_path,
+            "exit_code": error.exit_code,
+            "retryable": error.retryable,
+        }
+        if error.hint is not None:
+            data["hint"] = error.hint
+        if error.request_id is not None:
+            data["request_id"] = error.request_id
+        if error.remediation is not None:
+            data["remediation"] = error.remediation
+        return cls(kind="error", data=data)

vidbyte_cli/lib/runtime/__init__.py

@@ -0,0 +1,9 @@
+"""Runtime contracts that are safe to import from the package root.
+
+CliApplication and ApplicationContext are intentionally NOT re-exported: importing
+`vidbyte_cli` must not pull in click commands or HTTP models.
+"""
+
+from .version import VersionProvider, current_version
+
+__all__ = ["VersionProvider", "current_version"]

vidbyte_cli/lib/runtime/application.py

@@ -0,0 +1,134 @@
+"""One CLI invocation: read root policy, build the command tree, dispatch.
+
+This is the composition root. `run()` returns a status instead of calling `sys.exit`, so the
+application can be embedded in another Python process, and every failure — Click's included —
+leaves through the single ErrorHandler boundary rather than being printed here.
+
+Root options are inspected before Click parses, because `--format` and `--debug` decide how a
+parse failure is rendered and Click's own errors leave through that same boundary. They are
+overrides, not the final answer: the resolver layers them over the environment and the
+selected profile. An invocation that exits before running a command skips that resolution
+entirely, so `--help` never reads a file.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+from contextlib import redirect_stderr, redirect_stdout
+
+import click
+
+from ...commands import register_all_commands
+from ..config import ConfigOverrides
+from ..errors.failures import ConflictingOutputFormat
+from ..io import IOStreams
+from ..output.formats import ColorMode, OutputFormat
+from .context import ApplicationContext, InvocationOptions
+from .options import RootOptionInspector, RootOptionValues
+from .version import current_version
+
+
+class CliApplication:
+    """Runs one command-line invocation and returns its process status."""
+
+    def __init__(self, context: ApplicationContext | None = None) -> None:
+        # A caller may inject a complete graph; otherwise bind the process streams once.
+        self._context = context or ApplicationContext(IOStreams.system())
+        self._streams = self._context.streams
+
+    def run(self, argv: Sequence[str] | None = None) -> int:
+        # Build, configure, and dispatch inside one trap so every exit path is a return code.
+        arguments = list(sys.argv if argv is None else argv)
+        try:
+            program = self._build_program()
+            register_all_commands(program)
+            self._preconfigure(arguments)
+            return self._invoke(program, arguments)
+        except (Exception, KeyboardInterrupt) as error:  # noqa: BLE001 - the process boundary.
+            return self._context.error_handler().handle(error)
+        finally:
+            # After the handler has rendered, so a failure still reports before teardown.
+            self._context.close()
+
+    def _build_program(self) -> click.Group:
+        # The root group; its callback publishes the invocation context to every command.
+        application_context = self._context
+
+        @click.group(
+            name="vidbyte-cli",
+            help="Vidbyte CLI: hosted research and local agent runtimes",
+        )
+        @click.version_option(current_version(), "--version")
+        @click.option(
+            "--format",
+            "output_format",
+            type=click.Choice([item.value for item in OutputFormat], case_sensitive=False),
+            help="Select human, one-document, streaming, or suppressed result output.",
+        )
+        @click.option("--json", "as_json", is_flag=True, help="Alias for --format json.")
+        @click.option("--profile", type=str, help="Use a named configuration profile.")
+        @click.option("--no-input", is_flag=True, help="Never prompt for interactive input.")
+        @click.option(
+            "--color",
+            type=click.Choice([item.value for item in ColorMode], case_sensitive=False),
+            # No Click default: an unset flag must stay distinguishable from an explicit
+            # `--color auto`, or the option would outrank the stored profile every time.
+            default=None,
+        )
+        @click.option("--debug", is_flag=True, help="Show redacted internal stack frames.")
+        @click.pass_context
+        def program(click_context: click.Context, /, **values: object) -> None:
+            # Rebind root policy from Click, the authoritative parser, then publish context.
+            self._configure_context(RootOptionValues.from_click(values))
+            click_context.obj = application_context
+
+        return program
+
+    def _preconfigure(self, argv: Sequence[str]) -> None:
+        # Invalid root syntax stays service-free and is later rendered by Click.
+        inspection = RootOptionInspector(argv).inspect()
+        if inspection is None:
+            return
+        # Help and version exit before any command, and resolving configuration would read
+        # the filesystem on their behalf.
+        if not inspection.exits_before_command:
+            self._configure_context(inspection.values)
+
+    def _invoke(self, program: click.Group, argv: Sequence[str]) -> int:
+        # Click writes to the process streams, so bind them to the invocation-owned channels.
+        # standalone_mode=False hands click's exceptions back to the trap in run().
+        with redirect_stdout(self._streams.stdout), redirect_stderr(self._streams.stderr):
+            program.main(args=list(argv[1:]), prog_name="vidbyte-cli", standalone_mode=False)
+        return 0
+
+    def _configure_context(self, values: RootOptionValues) -> None:
+        # Root options are the highest-precedence layer, not the whole answer: the resolver
+        # fills every unset field from the environment, the profile, then built-ins.
+        resolved = self._context.config_resolver().resolve(
+            ConfigOverrides(
+                profile=values.profile,
+                output_format=self._resolve_output_format(values.output_format, values.as_json),
+                color=ColorMode(values.color) if values.color is not None else None,
+            )
+        )
+        self._context.configure(
+            InvocationOptions(
+                output_format=resolved.output_format,
+                profile=resolved.profile,
+                api_url=resolved.api_url,
+                request_timeout_seconds=resolved.request_timeout_seconds,
+                no_input=values.no_input,
+                color=resolved.color,
+                debug=values.debug,
+            ),
+            resolved,
+        )
+
+    def _resolve_output_format(self, value: str | None, as_json: bool) -> OutputFormat | None:
+        # --json is an alias, not an independent mode; duplicate JSON intent is harmless.
+        if as_json and value not in {None, OutputFormat.JSON.value}:
+            raise ConflictingOutputFormat()
+        if as_json:
+            return OutputFormat.JSON
+        return OutputFormat(value) if value is not None else None

vidbyte_cli/lib/runtime/context.py

@@ -0,0 +1,250 @@
+"""The dependency graph and presentation policy owned by exactly one invocation.
+
+Commands reach services through here instead of module globals. Everything expensive is
+built lazily, so `--help` and `--version` never touch the keyring, the config file, or the
+network — a keyring lookup can pop an OS unlock dialog, which no help invocation may do.
+
+Root options arrive through `configure()` before any command service exists, because output
+policy has to be settled before the first byte is written.
+
+The environment is injected rather than read at each use, so a test or an embedding process
+gets one place to control credential and configuration discovery.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+
+from ...types.provider import Provider
+from ..api.client import ApiClient
+from ..api.endpoints.billing import BillingEndpoints
+from ..api.endpoints.research import ResearchEndpoints
+from ..api.endpoints.runtime import RuntimeEndpoints
+from ..auth import (
+    ApiCredentialVerifier,
+    CredentialResolver,
+    CredentialStore,
+    CredentialVerifier,
+)
+from ..auth.credentials import Credentials
+from ..auth.provider_credentials import ProviderCredentials
+from ..auth.provider_resolver import ProviderResolver
+from ..auth.provider_store import ProviderCredentialStore
+from ..auth.provider_verifier import ProviderVerifier, verifier_for_provider
+from ..config import ConfigResolver, ConfigStore, ResolvedConfig, VidbytePaths
+from ..config.migration import StateMigration
+from ..config.models import DEFAULT_API_URL, DEFAULT_PROFILE
+from ..errors.failures import AuthenticationRequired, ProviderAuthenticationRequired
+from ..errors.handler import ErrorHandler
+from ..io import IOStreams
+from ..io.terminal import TerminalCapabilities, TerminalPolicy
+from ..output.formats import ColorMode, OutputFormat
+from ..output.manager import OutputManager, OutputPolicy
+from ..runtime_primitives import RuntimeExecutor, RuntimeHostRegistry, RuntimeLaunchPlanner
+
+
+@dataclass(frozen=True)
+class InvocationOptions:
+    """Root presentation, profile, and API policy resolved before command execution."""
+
+    output_format: OutputFormat = OutputFormat.HUMAN
+    profile: str = DEFAULT_PROFILE
+    api_url: str = DEFAULT_API_URL
+    request_timeout_seconds: float = 30.0
+    no_input: bool = False
+    color: ColorMode = ColorMode.AUTO
+    debug: bool = False
+
+
+class ApplicationContext:
+    """Invocation-scoped services, shared with commands via click's context object."""
+
+    def __init__(
+        self,
+        streams: IOStreams,
+        *,
+        environment: Mapping[str, str] | None = None,
+        paths: VidbytePaths | None = None,
+        verifier_factory: Callable[[], CredentialVerifier] | None = None,
+    ) -> None:
+        # Construction stays side-effect free; factories run on first request only.
+        self.streams = streams
+        self.environment = dict(os.environ if environment is None else environment)
+        self.options = InvocationOptions()
+        self._resolved_config: ResolvedConfig | None = None
+        self._paths = paths
+        self._config_store: ConfigStore | None = None
+        self._config_resolver: ConfigResolver | None = None
+        self._credential_store: CredentialStore | None = None
+        self._credential_resolver: CredentialResolver | None = None
+        self._migration: StateMigration | None = None
+        self._verifier_factory = verifier_factory or ApiCredentialVerifier
+        self._verifier: CredentialVerifier | None = None
+        self._output = self._build_output()
+        self._errors = ErrorHandler(self._output)
+        self._api_client: ApiClient | None = None
+        self._research_endpoints: ResearchEndpoints | None = None
+        self._runtime_endpoints: RuntimeEndpoints | None = None
+        self._billing_endpoints: BillingEndpoints | None = None
+        self._runtime_hosts: RuntimeHostRegistry | None = None
+        self._runtime_launch_planner: RuntimeLaunchPlanner | None = None
+        self._runtime_executor: RuntimeExecutor | None = None
+        self._provider_store: ProviderCredentialStore | None = None
+        self._provider_resolver: ProviderResolver | None = None
+
+    def configure(self, options: InvocationOptions, config: ResolvedConfig) -> None:
+        # Root options are read twice — once by the pre-scan, once by Click — so an unchanged
+        # policy must not rebuild the OutputManager and leave two disagreeing about a stream.
+        if options == self.options and config == self._resolved_config:
+            return
+        self.options = options
+        self._resolved_config = config
+        self._output = self._build_output()
+        self._errors = ErrorHandler(self._output, debug=options.debug)
+
+    def resolved_config(self) -> ResolvedConfig:
+        # A command reached for configuration without going through the root callback,
+        # which happens whenever Click short-circuits; resolve it on demand.
+        if self._resolved_config is None:
+            self._resolved_config = self.config_resolver().resolve()
+        return self._resolved_config
+
+    def paths(self) -> VidbytePaths:
+        if self._paths is None:
+            self._paths = VidbytePaths.default()
+        return self._paths
+
+    def config_store(self) -> ConfigStore:
+        if self._config_store is None:
+            self._config_store = ConfigStore(self.paths())
+        return self._config_store
+
+    def config_resolver(self) -> ConfigResolver:
+        if self._config_resolver is None:
+            self._config_resolver = ConfigResolver(self.config_store(), self.environment)
+        return self._config_resolver
+
+    def credential_store(self) -> CredentialStore:
+        if self._credential_store is None:
+            self._credential_store = CredentialStore(paths=self.paths())
+        return self._credential_store
+
+    def credential_resolver(self) -> CredentialResolver:
+        if self._credential_resolver is None:
+            self._credential_resolver = CredentialResolver(
+                self.credential_store(),
+                self.environment,
+            )
+        return self._credential_resolver
+
+    def migration(self) -> StateMigration:
+        if self._migration is None:
+            self._migration = StateMigration(
+                self.paths(),
+                self.config_store(),
+                self.credential_store().keyring,
+            )
+        return self._migration
+
+    def credential_verifier(self) -> CredentialVerifier:
+        if self._verifier is None:
+            self._verifier = self._verifier_factory()
+        return self._verifier
+
+    def require_credentials(self) -> Credentials:
+        # The API key for this invocation's profile and host, or a clean failure if none.
+        config = self.resolved_config()
+        resolved = self.credential_resolver().resolve(config.profile, config.api_url)
+        if resolved is None:
+            raise AuthenticationRequired()
+        return resolved.credentials
+
+    def api_client(self) -> ApiClient:
+        # One client per invocation, so a polling command reuses a single connection pool.
+        if self._api_client is None:
+            self._api_client = ApiClient(self.resolved_config(), self.require_credentials())
+        return self._api_client
+
+    def research_endpoints(self) -> ResearchEndpoints:
+        # The authenticated research route group; requires a logged-in user.
+        if self._research_endpoints is None:
+            self._research_endpoints = ResearchEndpoints(self.api_client())
+        return self._research_endpoints
+
+    def runtime_endpoints(self) -> RuntimeEndpoints:
+        # Lazily binds runtime HTTP operations to this invocation's authenticated client.
+        if self._runtime_endpoints is None:
+            self._runtime_endpoints = RuntimeEndpoints(self.api_client())
+        return self._runtime_endpoints
+
+    def billing_endpoints(self) -> BillingEndpoints:
+        # Lazily binds billing HTTP operations to this invocation's API client.
+        if self._billing_endpoints is None:
+            self._billing_endpoints = BillingEndpoints(self.api_client())
+        return self._billing_endpoints
+
+    def runtime_hosts(self) -> RuntimeHostRegistry:
+        # Shares one PATH discovery policy between doctor and launch planning.
+        if self._runtime_hosts is None:
+            self._runtime_hosts = RuntimeHostRegistry()
+        return self._runtime_hosts
+
+    def runtime_launch_planner(self) -> RuntimeLaunchPlanner:
+        # Builds local launch plans without credentials, network calls, or subprocesses.
+        if self._runtime_launch_planner is None:
+            self._runtime_launch_planner = RuntimeLaunchPlanner(self.runtime_hosts())
+        return self._runtime_launch_planner
+
+    def runtime_executor(self) -> RuntimeExecutor:
+        # Returns the inert boundary a later runtime implementation will replace.
+        if self._runtime_executor is None:
+            self._runtime_executor = RuntimeExecutor()
+        return self._runtime_executor
+
+    def close(self) -> None:
+        # Releases network resources this invocation opened; a help path opened none.
+        if self._api_client is not None:
+            self._api_client.close()
+
+    def output(self) -> OutputManager:
+        # Callers share one policy object so stdout cardinality stays enforceable.
+        return self._output
+
+    def provider_store(self) -> ProviderCredentialStore:
+        # Lazily created so --help never opens the keyring.
+        if self._provider_store is None:
+            self._provider_store = ProviderCredentialStore(paths=self.paths())
+        return self._provider_store
+
+    def provider_resolver(self) -> ProviderResolver:
+        # Env > keyring > file, scoped by profile+provider.
+        if self._provider_resolver is None:
+            self._provider_resolver = ProviderResolver(self.provider_store(), self.environment)
+        return self._provider_resolver
+
+    def provider_verifier(self, provider: Provider) -> ProviderVerifier:
+        # Factory keeps command from branching on provider.
+        return verifier_for_provider(provider)
+
+    def require_provider_credentials(self, provider: Provider) -> ProviderCredentials:
+        # Provider key for this profile, or a typed failure before any network call.
+        config = self.resolved_config()
+        resolved = self.provider_resolver().resolve(config.profile, provider)
+        if resolved is None:
+            raise ProviderAuthenticationRequired(provider.value)
+        return resolved.credentials
+
+    def error_handler(self) -> ErrorHandler:
+        return self._errors
+
+    def _build_output(self) -> OutputManager:
+        # Terminal detection reruns whenever color or no-input preferences change.
+        terminal_policy = TerminalPolicy(
+            self.options.color,
+            self.options.no_input,
+            self.environment,
+        )
+        terminal = TerminalCapabilities.detect(self.streams, terminal_policy)
+        return OutputManager(self.streams, OutputPolicy(self.options.output_format, terminal))