harn-stdlib 0.9.6

/**
 * `harn models lora inspect` renderer.
 *
 * The dispatch shim reads adapter files, provider catalog metadata, and model
 * capability tables in Rust because those host surfaces are not script
 * builtins yet. It hands this script a single JSON report; this Harn source
 * owns the user-facing text and JSON passthrough.
 *
 * Inputs (from the dispatch shim):
 *   HARN_MODELS_LORA_INSPECT_PAYLOAD_JSON   — compact report JSON.
 *   HARN_MODELS_LORA_INSPECT_PAYLOAD_PRETTY — pretty report JSON.
 *   HARN_OUTPUT_JSON                        — "1" for JSON, else human text.
 */
import {
  cli_json_envelope,
  join_shell_argv,
  nonempty_string,
  safe_bool,
  safe_dict,
  safe_int_string,
  safe_list,
  safe_string,
} from "std/cli/render"

fn __base_match_label(value: string) -> string {
  if value == "exact" {
    return "exact"
  }
  if value == "suffix" {
    return "same basename"
  }
  if value == "mismatch" {
    return "mismatch"
  }
  return "unknown"
}

fn __render_human(harness: Harness, report: dict) {
  let base = safe_dict(report["base"])
  let adapter = safe_dict(report["adapter"])
  let compatibility = safe_dict(report["compatibility"])
  let launch = safe_dict(report["launch"])
  let tool_calling = safe_dict(report["tool_calling"])
  let warnings = safe_list(report["warnings"])
  let adapter_name = safe_string(adapter["name"], "lora-adapter")
  let base_id = safe_string(base["id"], "")
  let provider = safe_string(base["provider"], "")
  harness.stdio.println(adapter_name + " -> " + base_id + " via " + provider)
  harness.stdio.println("  adapter: " + safe_string(adapter["input"], ""))
  harness.stdio
    .println(
    "  base match: "
      + __base_match_label(safe_string(compatibility["base_model_match"], "unknown")),
  )
  harness.stdio.println("  tool format: " + safe_string(base["tool_format"], ""))
  harness.stdio
    .println("  request model: " + safe_string(launch["request_model"], adapter_name))
  let native_tools = if safe_bool(tool_calling["native_tools"], false) {
    "yes"
  } else {
    "no"
  }
  harness.stdio
    .println(
    "  native tools: "
      + native_tools
      + ", preferred: "
      + nonempty_string(tool_calling["preferred_tool_format"], "unset"),
  )
  let launch_supported = if safe_bool(compatibility["provider_supports_lora_launch"], false) {
    "yes"
  } else {
    "no"
  }
  harness.stdio.println("  catalog LoRA launch flags: " + launch_supported)
  let module_format = safe_string(compatibility["provider_lora_module_value_format"], "")
  if module_format != "" {
    harness.stdio.println("  LoRA module format: " + module_format)
  }
  let rank_supported = if safe_bool(compatibility["provider_supports_lora_max_rank"], false) {
    "yes"
  } else {
    "no"
  }
  harness.stdio.println("  catalog LoRA rank flag: " + rank_supported)
  let max_rank = safe_int_string(launch["max_lora_rank"], "")
  if max_rank != "" {
    harness.stdio.println("  max LoRA rank: " + max_rank)
  }
  for warning in warnings {
    let text = safe_string(warning, "")
    if text != "" {
      harness.stdio.println("  warning: " + text)
    }
  }
  let launch_argv = safe_list(launch["harn_local_launch"])
  if launch_argv.count != 0 {
    harness.stdio.println("  launch:")
    harness.stdio.println("    " + join_shell_argv(launch_argv, " "))
  }
}

fn __render_json(report: dict) -> string {
  let ok = safe_bool(report["ok"], false)
  let envelope = if ok {
    cli_json_envelope({schema_version: 1, ok: true, data: report})
  } else {
    cli_json_envelope(
      {
        schema_version: 1,
        ok: false,
        error: {
          code: "lora_inspect_failed",
          message: "LoRA adapter inspection found an incompatible or incomplete adapter.",
          details: report,
        },
      },
    )
  }
  return json_stringify_pretty(envelope)
}

fn main(harness: Harness) -> int {
  let raw = harness.env.get_or("HARN_MODELS_LORA_INSPECT_PAYLOAD_JSON", "")
  if raw == "" {
    harness.stdio
      .eprintln("internal error: HARN_MODELS_LORA_INSPECT_PAYLOAD_JSON not set by dispatch shim")
    return 70
  }
  let report = try {
    json_parse(raw)
  } catch (e) {
    harness.stdio.eprintln("internal error: failed to parse LoRA inspect payload: " + to_string(e))
    return 70
  }
  let ok = safe_bool(report["ok"], false)
  let json_mode = harness.env.get_or("HARN_OUTPUT_JSON", "0") == "1"
  if json_mode {
    harness.stdio.println(__render_json(report))
  } else {
    __render_human(harness, report)
  }
  if ok {
    return 0
  }
  return 1
}