/**
* `harn models lora manifest` renderer.
*
* Rust resolves route/catalog facts and writes the manifest file. This Harn
* source owns the human/JSON presentation for the canonical manifest report.
*
* Inputs (from the dispatch shim):
* HARN_MODELS_LORA_MANIFEST_PAYLOAD_JSON - compact report JSON.
* HARN_MODELS_LORA_MANIFEST_PAYLOAD_PRETTY - pretty report JSON.
* HARN_OUTPUT_JSON - "1" for JSON, else human text.
*/
import {
cli_json_envelope,
print_list,
render_command,
safe_bool,
safe_dict,
safe_int_string,
safe_list,
safe_number_string,
safe_string,
} from "std/cli/render"
fn __path_line(harness: Harness, label: string, value: unknown) {
let path_ref = safe_dict(value)
let path = safe_string(path_ref["path"], "")
if path == "" {
return
}
let exists = if safe_bool(path_ref["exists"], false) {
"yes"
} else {
"no"
}
let hash = safe_string(path_ref["sha256"], "")
let suffix = if hash == "" {
""
} else {
" sha256=" + hash
}
harness.stdio
.println(
" "
+ label
+ ": "
+ path
+ " ("
+ safe_string(path_ref["kind"], "")
+ ", exists="
+ exists
+ ")"
+ suffix,
)
}
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 = safe_dict(report["training"])
let training_contract = safe_dict(training["contract"])
let precision = safe_dict(training["precision"])
let template = safe_dict(training["template"])
let inputs = safe_dict(report["inputs"])
let artifacts = safe_dict(report["artifacts"])
let serving = safe_dict(report["serving"])
let promotion = safe_dict(report["promotion"])
let warnings = safe_list(report["warnings"])
harness.stdio
.println(
"LoRA manifest for "
+ safe_string(target["adapter_name"], "")
+ " on "
+ safe_string(base["id"], "")
+ " via "
+ safe_string(base["provider"], ""),
)
harness.stdio.println(" producer: " + safe_string(report["producer"], ""))
let output = safe_string(request["output"], "")
if output != "" {
harness.stdio.println(" output: " + output)
}
let run_id = safe_string(training["run_id"], "")
if run_id != "" {
harness.stdio.println(" training run: " + run_id)
}
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(" chat template: " + safe_string(target["chat_template"], ""))
harness.stdio.println(" contract: " + safe_string(contract["id"], ""))
harness.stdio.println(" request model: " + safe_string(target["request_model"], ""))
harness.stdio.println(" trainer: " + safe_string(training["trainer"], ""))
harness.stdio
.println(
" training: "
+ safe_string(training["method"], "")
+ " + "
+ safe_string(training["adapter_type"], ""),
)
harness.stdio
.println(
" LoRA hparams: rank="
+ safe_int_string(training["rank"], "")
+ " alpha="
+ safe_int_string(training["alpha"], "")
+ " dropout="
+ safe_number_string(training["dropout"], ""),
)
let target_modules = safe_list(training["target_modules"])
if len(target_modules) > 0 {
harness.stdio
.println(
" target modules: " + join(target_modules.map({ item -> safe_string(item, "") }), ", "),
)
}
harness.stdio
.println(" assistant mask: " + safe_string(training_contract["assistant_mask_policy"], ""))
harness.stdio
.println(" parser owner: " + safe_string(training_contract["tool_parser_owner"], ""))
harness.stdio
.println(" split policy: " + safe_string(training_contract["dataset_split_policy"], ""))
harness.stdio
.println(
" training base precision: "
+ safe_string(precision["training_base_precision"], ""),
)
harness.stdio
.println(
" training compute precision: "
+ safe_string(precision["training_compute_precision"], ""),
)
harness.stdio
.println(" adapter precision: " + safe_string(precision["adapter_weight_precision"], ""))
harness.stdio
.println(" serving base precision: " + safe_string(precision["serving_base_precision"], ""))
harness.stdio.println(" template: " + safe_string(template["name"], ""))
harness.stdio.println(" template source: " + safe_string(template["source"], ""))
__path_line(harness, "dataset", inputs["dataset"])
__path_line(harness, "corpus", inputs["corpus"])
__path_line(harness, "export manifest", inputs["export_manifest"])
let teacher = safe_dict(inputs["teacher"])
let teacher_id = safe_string(teacher["id"], "")
if teacher_id != "" {
harness.stdio.println(" teacher: " + teacher_id + " via " + safe_string(teacher["provider"], ""))
}
let adapter_reference = safe_string(artifacts["adapter_reference"], "")
if adapter_reference != "" {
harness.stdio.println(" adapter reference: " + adapter_reference)
}
__path_line(harness, "adapter path", artifacts["local_path"])
for item in safe_list(artifacts["adapter_files"]) {
__path_line(harness, "adapter file", item)
}
harness.stdio.println(" adapter binding: " + safe_string(serving["adapter_binding"], ""))
harness.stdio
.println(" LoRA module format: " + safe_string(serving["lora_module_value_format"], ""))
harness.stdio
.println(" promotion minimum trials: " + safe_int_string(promotion["minimum_trials"], "0"))
harness.stdio
.println(" promotion baseline: " + safe_string(promotion["comparison_baseline"], ""))
print_list(harness, "template requirements", safe_list(template["requirements"]))
print_list(harness, "precision gates", safe_list(precision["promotion_gates"]))
print_list(harness, "promotion metrics", safe_list(promotion["required_metrics"]))
print_list(harness, "promotion gates", safe_list(promotion["gates"]))
render_command(harness, "eval", safe_list(promotion["eval_command"]))
print_list(harness, "warnings", warnings)
}
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_manifest_failed",
message: "LoRA manifest did not produce a usable training contract.",
details: report,
},
},
)
}
return json_stringify_pretty(envelope)
}
fn main(harness: Harness) -> int {
let raw = harness.env.get_or("HARN_MODELS_LORA_MANIFEST_PAYLOAD_JSON", "")
if raw == "" {
harness.stdio.eprintln("internal error: HARN_MODELS_LORA_MANIFEST_PAYLOAD_JSON not set")
return 70
}
let report = try {
json_parse(raw)
} catch (e) {
harness.stdio.eprintln("internal error: failed to parse LoRA manifest 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
}