sv-cli 0.3.0__py3-none-any.whl

sv_cli/executor.py

@@ -0,0 +1,188 @@
+"""Generic tool execution layer."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+from .adapters import get_adapter
+from .api_client import APIClient
+from .config import resolve_api_key
+from .definitions import DefinitionsManager
+from .errors import ConfigError, InvalidInputError
+from .formatter import print_output
+from .resolver import extract_option_sets, resolve_api_field, resolve_enum_value
+from .tasks import extract_task_id, save_task, wait_for_task
+from .utils import coerce_mapping_values, mask_mapping, maybe_read_file_value
+
+
+@dataclass
+class RuntimeOptions:
+    profile: str | None = None
+    api_key: str | None = None
+    base_url: str | None = None
+    output_format: str = "pretty"
+    output: str | None = None
+    quiet: bool = False
+    verbose: bool = False
+    debug: bool = False
+    strict: bool = False
+    no_fuzzy: bool = False
+    non_interactive: bool = False
+
+
+@dataclass
+class WaitOptions:
+    wait: bool = False
+    timeout: int = 600
+    poll_interval: int = 5
+    no_progress: bool = False
+
+
+def load_json_payload(
+    *, json_payload: str | None = None, file_path: str | None = None, stdin_payload: str | None = None
+) -> dict[str, Any]:
+    supplied = [json_payload is not None, file_path is not None, stdin_payload is not None]
+    if sum(bool(item) for item in supplied) != 1:
+        raise InvalidInputError("Provide exactly one of --json, --file, or --stdin for raw call payloads.")
+    if json_payload is not None:
+        source = json_payload
+    elif file_path is not None:
+        source = Path(file_path).expanduser().read_text(encoding="utf-8")
+    else:
+        source = stdin_payload or ""
+    try:
+        payload = json.loads(source)
+    except json.JSONDecodeError as exc:
+        raise InvalidInputError(f"Invalid JSON payload: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise InvalidInputError("Raw call payload must be a JSON object.")
+    return payload
+
+
+def build_payload(
+    *,
+    tool: str,
+    action: str | None,
+    params: dict[str, Any],
+    definition: Any,
+    strict: bool,
+    fuzzy: bool,
+    non_interactive: bool,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    if action and action != "raw":
+        payload["action"] = normalize_action(action)
+
+    params = coerce_mapping_values({key: value for key, value in params.items() if value is not None})
+    option_sets = extract_option_sets(definition)
+
+    for cli_field, value in params.items():
+        if cli_field in {"json", "file", "stdin"}:
+            continue
+        if cli_field == "keywords" and isinstance(value, str):
+            value = maybe_read_file_value(value)
+        if cli_field == "outline" and isinstance(value, str):
+            value = maybe_read_file_value(value)
+
+        api_field, candidates = resolve_api_field(tool, cli_field, definition)
+        if candidates is None:
+            candidates = option_sets.get(api_field)
+        if candidates:
+            value = resolve_enum_value(
+                api_field,
+                value,
+                candidates,
+                strict=strict,
+                fuzzy=fuzzy,
+                non_interactive=non_interactive,
+            )
+        payload[api_field] = value
+    return payload
+
+
+def normalize_action(action: str) -> str:
+    parts = action.split("-")
+    return parts[0] + "".join(p.capitalize() for p in parts[1:])
+
+
+def execute_tool(
+    *,
+    tool_name: str,
+    action: str | None,
+    params: dict[str, Any],
+    runtime: RuntimeOptions,
+    wait_options: WaitOptions | None = None,
+    raw_payload: dict[str, Any] | None = None,
+    method: str = "POST",
+    console: Console | None = None,
+) -> Any:
+    console = console or Console()
+    definitions = DefinitionsManager(runtime.base_url)
+    entry = definitions.get_tool(tool_name)
+    tool = entry["tool"]
+    endpoint = entry.get("endpoint")
+    if not endpoint:
+        raise ConfigError(f'Tool "{tool}" does not have an endpoint in the API root.')
+    definition = entry.get("definition") or {}
+    api_key = resolve_api_key(
+        cli_api_key=runtime.api_key,
+        profile=runtime.profile,
+        allow_prompt=not runtime.non_interactive,
+        non_interactive=runtime.non_interactive,
+    )
+
+    if raw_payload is not None:
+        payload = dict(raw_payload)
+    else:
+        payload = build_payload(
+            tool=tool,
+            action=action,
+            params=params,
+            definition=definition,
+            strict=runtime.strict,
+            fuzzy=not runtime.no_fuzzy,
+            non_interactive=runtime.non_interactive,
+        )
+
+    client = APIClient(debug=runtime.debug, console=Console(stderr=True))
+    response = client.request_tool(endpoint=str(endpoint), payload=payload, api_key=api_key, method=method)
+    data = response.data
+
+    task_id = extract_task_id(data)
+    if task_id:
+        save_task(task_id, tool, str(endpoint))
+
+    if wait_options and wait_options.wait:
+        if not task_id:
+            if runtime.verbose or runtime.debug:
+                Console(stderr=True).print("[yellow]--wait was set, but no task ID was found in the response.[/yellow]")
+        else:
+            data = wait_for_task(
+                task_id=task_id,
+                tool=tool,
+                api_key=api_key,
+                definitions=definitions,
+                client=client,
+                timeout_seconds=wait_options.timeout,
+                poll_interval=wait_options.poll_interval,
+                no_progress=wait_options.no_progress or runtime.quiet,
+                console=Console(stderr=True),
+            )
+
+    if runtime.debug:
+        Console(stderr=True).print("[dim]Resolved payload:[/dim]")
+        Console(stderr=True).print_json(json.dumps(mask_mapping(payload), ensure_ascii=False))
+
+    if not runtime.quiet:
+        print_output(console, data, runtime.output_format, runtime.output)
+    return data
+
+
+def adapter_default_action(tool: str) -> str:
+    adapter = get_adapter(tool)
+    return adapter.default_action if adapter else "run"

sv_cli/formatter.py

@@ -0,0 +1,227 @@
+"""Output formatters for human and machine use."""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.table import Table
+
+from .errors import UnsupportedFeatureError
+from .utils import ensure_parent, mask_mapping
+
+SUPPORTED_FORMATS = {"pretty", "json", "table", "csv", "markdown", "text"}
+
+
+def render_output(data: Any, fmt: str = "pretty") -> str | None:
+    fmt = fmt.lower()
+    if fmt not in SUPPORTED_FORMATS:
+        raise UnsupportedFeatureError(
+            f'Unsupported output format "{fmt}". Use one of: {", ".join(sorted(SUPPORTED_FORMATS))}'
+        )
+    safe_data = mask_mapping(data)
+    if fmt == "json":
+        return json.dumps(safe_data, indent=2, ensure_ascii=False)
+    if fmt == "csv":
+        return to_csv(safe_data)
+    if fmt == "markdown":
+        return to_markdown(safe_data)
+    if fmt == "text":
+        return to_text(safe_data)
+    if fmt == "table":
+        return to_table_text(safe_data)
+    return None
+
+
+def print_output(console: Console, data: Any, fmt: str = "pretty", output: str | None = None) -> None:
+    rendered = render_output(data, fmt)
+    if output:
+        path = Path(output).expanduser()
+        ensure_parent(path)
+        if rendered is None:
+            rendered = to_text(mask_mapping(data))
+        path.write_text(rendered + ("" if rendered.endswith("\n") else "\n"), encoding="utf-8")
+        return
+    if rendered is not None:
+        if fmt == "json":
+            # Bypass Rich — it word-wraps long lines, inserting literal newlines
+            # inside JSON string values and producing unparseable output.
+            sys.stdout.write(rendered + "\n")
+        else:
+            console.print(rendered)
+        return
+    print_pretty(console, mask_mapping(data))
+
+
+def print_pretty(console: Console, data: Any) -> None:
+    if isinstance(data, dict):
+        primary_text = extract_primary_text(data)
+        rows = find_tabular_data(data)
+        if primary_text and not rows:
+            console.print(primary_text)
+            return
+        if rows:
+            print_table(console, rows)
+            extra = {k: v for k, v in data.items() if v is not rows and not isinstance(v, list)}
+            if extra:
+                console.print_json(json.dumps(extra, ensure_ascii=False))
+            return
+        console.print_json(json.dumps(data, ensure_ascii=False))
+        return
+    if isinstance(data, list):
+        if data and all(isinstance(item, dict) for item in data):
+            print_table(console, data)
+        else:
+            console.print_json(json.dumps(data, ensure_ascii=False))
+        return
+    console.print(str(data))
+
+
+def extract_primary_text(data: dict[str, Any]) -> str | None:
+    for key in ("text", "content", "result", "output", "answer", "message"):
+        value = data.get(key)
+        if isinstance(value, str):
+            return value
+    nested = data.get("data")
+    if isinstance(nested, str):
+        return nested
+    if isinstance(nested, dict):
+        return extract_primary_text(nested)
+    return None
+
+
+def find_tabular_data(data: Any) -> list[dict[str, Any]] | None:
+    if isinstance(data, list) and all(isinstance(item, dict) for item in data):
+        return data
+    if isinstance(data, dict):
+        for key in ("keywords", "results", "items", "data", "rows", "records"):
+            value = data.get(key)
+            if isinstance(value, list) and all(isinstance(item, dict) for item in value):
+                return value
+    return None
+
+
+def to_csv(data: Any) -> str:
+    rows = find_tabular_data(data)
+    if rows is None:
+        raise UnsupportedFeatureError("CSV output requires a list of records in the API response.")
+    if not rows:
+        return ""
+    fieldnames: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in fieldnames:
+                fieldnames.append(key)
+    buffer = io.StringIO()
+    writer = csv.DictWriter(buffer, fieldnames=fieldnames, extrasaction="ignore")
+    writer.writeheader()
+    for row in rows:
+        writer.writerow({key: serialize_cell(row.get(key)) for key in fieldnames})
+    return buffer.getvalue().rstrip("\n")
+
+
+def to_markdown(data: Any) -> str:
+    rows = find_tabular_data(data)
+    if rows:
+        return rows_to_markdown(rows)
+    if isinstance(data, dict):
+        primary = extract_primary_text(data)
+        if primary:
+            return primary
+        lines = []
+        for key, value in data.items():
+            lines.append(f"## {key}\n")
+            lines.append(value if isinstance(value, str) else f"```json\n{json.dumps(value, indent=2, ensure_ascii=False)}\n```")
+        return "\n\n".join(lines)
+    if isinstance(data, list):
+        return "\n".join(f"- {serialize_cell(item)}" for item in data)
+    return str(data)
+
+
+def rows_to_markdown(rows: list[dict[str, Any]]) -> str:
+    if not rows:
+        return ""
+    fieldnames: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in fieldnames:
+                fieldnames.append(key)
+    header = "| " + " | ".join(fieldnames) + " |"
+    divider = "| " + " | ".join("---" for _ in fieldnames) + " |"
+    body = [
+        "| " + " | ".join(escape_markdown_table(serialize_cell(row.get(key))) for key in fieldnames) + " |"
+        for row in rows
+    ]
+    return "\n".join([header, divider, *body])
+
+
+def to_text(data: Any) -> str:
+    if isinstance(data, str):
+        return data
+    if isinstance(data, dict):
+        primary = extract_primary_text(data)
+        if primary:
+            return primary
+    return json.dumps(data, indent=2, ensure_ascii=False)
+
+
+def to_table_text(data: Any) -> str:
+    rows = find_tabular_data(data)
+    if rows is None:
+        raise UnsupportedFeatureError("Table output requires a list of records in the API response.")
+    if not rows:
+        return "(no results)"
+    # Plain text table for file output and non-rich paths.
+    fieldnames: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in fieldnames:
+                fieldnames.append(key)
+    widths = {
+        key: max(len(str(key)), *(len(serialize_cell(row.get(key))) for row in rows)) for key in fieldnames
+    }
+    lines = []
+    lines.append("  ".join(str(key).ljust(widths[key]) for key in fieldnames))
+    lines.append("  ".join("-" * widths[key] for key in fieldnames))
+    for row in rows:
+        lines.append("  ".join(serialize_cell(row.get(key)).ljust(widths[key]) for key in fieldnames))
+    return "\n".join(lines)
+
+
+def print_table(console: Console, rows: list[dict[str, Any]]) -> None:
+    if not rows:
+        console.print("No rows returned.")
+        return
+    fieldnames: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in fieldnames:
+                fieldnames.append(str(key))
+    table = Table(show_header=True, header_style="bold")
+    for key in fieldnames:
+        table.add_column(str(key))
+    for row in rows:
+        table.add_row(*(serialize_cell(row.get(key)) for key in fieldnames))
+    console.print(table)
+
+
+def print_markdown(console: Console, text: str) -> None:
+    console.print(Markdown(text))
+
+
+def serialize_cell(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, ensure_ascii=False)
+    return str(value)
+
+
+def escape_markdown_table(value: str) -> str:
+    return value.replace("|", "\\|").replace("\n", "<br>")