harn-stdlib 0.9.6

/**
 * `harn models lora export` renderer.
 *
 * The dispatch shim resolves model/catalog facts and writes dataset rows. This
 * Harn source owns the report presentation and JSON passthrough.
 *
 * Inputs (from the dispatch shim):
 *   HARN_MODELS_LORA_EXPORT_PAYLOAD_JSON   - compact report JSON.
 *   HARN_MODELS_LORA_EXPORT_PAYLOAD_PRETTY - pretty report JSON.
 *   HARN_OUTPUT_JSON                       - "1" for JSON, else human text.
 */
import {
  cli_json_envelope,
  print_list,
  safe_bool,
  safe_dict,
  safe_int_string,
  safe_list,
  safe_string,
} from "std/cli/render"

fn __render_human(harness: Harness, report: dict) {
  let base = safe_dict(report["base"])
  let request = safe_dict(report["request"])
  let target = safe_dict(report["target"])
  let contract = safe_dict(report["contract"])
  let training_contract = safe_dict(contract["training_contract"])
  let serving = safe_dict(report["serving"])
  let output = safe_dict(report["output"])
  let stats = safe_dict(report["stats"])
  let warnings = safe_list(report["warnings"])
  let errors = safe_list(report["errors"])
  let base_id = safe_string(base["id"], "")
  let provider = safe_string(base["provider"], "")
  harness.stdio.println("LoRA export for " + base_id + " via " + provider)
  harness.stdio.println("  corpus: " + safe_string(request["corpus"], ""))
  harness.stdio
    .println(
    "  tool format: "
      + safe_string(request["effective_tool_format"], "")
      + " (requested "
      + safe_string(request["requested_tool_format"], "auto")
      + ")",
  )
  harness.stdio.println("  dataset format: " + safe_string(request["dataset_format"], ""))
  harness.stdio.println("  contract: " + safe_string(contract["id"], ""))
  harness.stdio
    .println(
    "  contract assistant mask: "
      + safe_string(training_contract["assistant_mask_policy"], ""),
  )
  harness.stdio
    .println("  contract parser owner: " + safe_string(training_contract["tool_parser_owner"], ""))
  harness.stdio
    .println(
    "  contract split policy: "
      + safe_string(training_contract["dataset_split_policy"], ""),
  )
  harness.stdio.println("  target base: " + safe_string(target["base_model"], ""))
  let adapter = safe_string(target["adapter_name"], "")
  if adapter != "" {
    harness.stdio.println("  adapter name: " + adapter)
  }
  let template = safe_string(target["chat_template"], "")
  if template != "" {
    harness.stdio.println("  chat template: " + template)
  }
  harness.stdio.println("  adapter binding: " + safe_string(serving["adapter_binding"], ""))
  harness.stdio
    .println("  LoRA module format: " + safe_string(serving["lora_module_value_format"], ""))
  let request_model = safe_string(serving["request_model"], "")
  if request_model != "" {
    harness.stdio.println("  request model: " + request_model)
  }
  let path = safe_string(output["path"], "")
  if path != "" {
    harness.stdio.println("  output: " + path)
  }
  let manifest = safe_string(output["manifest_path"], "")
  if manifest != "" {
    harness.stdio.println("  manifest: " + manifest)
  }
  if safe_bool(request["check"], false) {
    harness.stdio.println("  mode: check")
  }
  harness.stdio
    .println(
    "  stats: records="
      + safe_int_string(stats["records"], "0")
      + " emitted="
      + safe_int_string(stats["emitted"], "0")
      + " skipped="
      + safe_int_string(stats["skipped"], "0")
      + " tool_calls="
      + safe_int_string(stats["tool_calls"], "0")
      + " tool_results="
      + safe_int_string(stats["tool_results"], "0"),
  )
  print_list(harness, "warnings", warnings)
  print_list(harness, "errors", errors)
}

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_export_failed",
          message: "LoRA dataset export failed validation or conversion.",
          details: report,
        },
      },
    )
  }
  return json_stringify_pretty(envelope)
}

fn main(harness: Harness) -> int {
  let raw = harness.env.get_or("HARN_MODELS_LORA_EXPORT_PAYLOAD_JSON", "")
  if raw == "" {
    harness.stdio.eprintln("internal error: HARN_MODELS_LORA_EXPORT_PAYLOAD_JSON not set")
    return 70
  }
  let report = try {
    json_parse(raw)
  } catch (e) {
    harness.stdio.eprintln("internal error: failed to parse LoRA export 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
}