/**
* `harn models lora plan` renderer.
*
* The dispatch shim resolves model aliases, provider capabilities, and catalog
* launch facts in Rust. This Harn source owns the portable training/eval
* recipe and the human/JSON presentation.
*
* Inputs (from the dispatch shim):
* HARN_MODELS_LORA_PLAN_PAYLOAD_JSON - compact report JSON.
* HARN_MODELS_LORA_PLAN_PAYLOAD_PRETTY - pretty report JSON.
* HARN_OUTPUT_JSON - "1" for JSON, else human text.
*/
import {
cli_json_envelope,
nonempty_string,
print_list,
render_command,
safe_bool,
safe_dict,
safe_int_string,
safe_list,
safe_number_string,
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 tool_calling = safe_dict(report["tool_calling"])
let training = safe_dict(report["training"])
let training_contract = safe_dict(training["contract"])
let template = safe_dict(report["template"])
let data = safe_dict(report["data"])
let corpus_refresh = safe_dict(report["corpus_refresh"])
let evaluation = safe_dict(report["evaluation"])
let serving = safe_dict(report["serving"])
let launch = safe_dict(report["launch"])
let warnings = safe_list(report["warnings"])
let base_id = safe_string(base["id"], "")
let provider = safe_string(base["provider"], "")
harness.stdio.println("LoRA plan for " + base_id + " via " + provider)
harness.stdio.println(" base selector: " + safe_string(base["selector"], ""))
harness.stdio
.println(
" tool format: "
+ safe_string(request["effective_tool_format"], "")
+ " (requested "
+ safe_string(request["requested_tool_format"], "auto")
+ ")",
)
let correction = safe_string(request["tool_format_correction"], "")
if correction != "" {
harness.stdio.println(" tool format correction: " + correction)
}
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"),
)
harness.stdio
.println(
" training: "
+ safe_string(request["method"], "")
+ " + "
+ safe_string(training["adapter_type"], ""),
)
harness.stdio.println(" trainer: " + safe_string(training["trainer"], ""))
harness.stdio
.println(
" LoRA hparams: rank="
+ safe_int_string(training["rank"], "")
+ " alpha="
+ safe_int_string(training["alpha"], "")
+ " dropout="
+ safe_number_string(training["dropout"], ""),
)
harness.stdio.println(" quantization: " + safe_string(training["quantization"], ""))
harness.stdio.println(" loss scope: " + safe_string(training["loss_scope"], ""))
harness.stdio.println(" packing: " + safe_string(training["packing"], ""))
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(" template: " + safe_string(template["name"], ""))
harness.stdio.println(" template source: " + safe_string(template["source"], ""))
harness.stdio.println(" supervised target: " + safe_string(template["supervised_target"], ""))
let corpus = safe_string(request["corpus"], "")
if corpus != "" {
harness.stdio.println(" corpus: " + corpus)
}
harness.stdio
.println(
" corpus strategy: "
+ safe_string(request["effective_corpus_strategy"], "")
+ " (requested "
+ safe_string(request["requested_corpus_strategy"], "auto")
+ ")",
)
let teacher = safe_dict(request["teacher"])
let teacher_id = safe_string(teacher["id"], "")
if teacher_id != "" {
harness.stdio
.println(
" teacher: "
+ teacher_id
+ " via "
+ safe_string(teacher["provider"], ""),
)
}
harness.stdio.println(" dataset format: " + safe_string(data["dataset_format"], ""))
print_list(harness, "template requirements", safe_list(template["requirements"]))
print_list(harness, "stop sequences", safe_list(template["stop_sequences"]))
print_list(harness, "template notes", safe_list(template["notes"]))
print_list(harness, "required columns", safe_list(data["required_columns"]))
print_list(harness, "data validation", safe_list(data["validation"]))
print_list(harness, "corpus refresh", safe_list(corpus_refresh["generation_notes"]))
print_list(harness, "provenance manifest", safe_list(corpus_refresh["provenance_manifest_fields"]))
print_list(harness, "hard negatives", safe_list(corpus_refresh["hard_negative_slices"]))
print_list(harness, "corpus gates", safe_list(corpus_refresh["acceptance_gates"]))
print_list(harness, "trainer contract", safe_list(training["trainer_contract"]))
print_list(harness, "training notes", safe_list(training["notes"]))
harness.stdio
.println(" holdout policy: " + safe_string(evaluation["holdout_policy"], ""))
harness.stdio
.println(" minimum trials: " + safe_int_string(evaluation["minimum_trials"], "0"))
harness.stdio
.println(" comparison baseline: " + safe_string(evaluation["comparison_baseline"], ""))
print_list(harness, "required metrics", safe_list(evaluation["required_metrics"]))
print_list(harness, "eval gates", safe_list(evaluation["gates"]))
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(" request model: " + safe_string(serving["request_model"], ""))
print_list(harness, "serving notes", safe_list(serving["runtime_notes"]))
print_list(harness, "promotion gates", safe_list(serving["promotion_gates"]))
render_command(harness, "export dataset", safe_list(launch["export_command"]))
render_command(harness, "eval", safe_list(evaluation["eval_command"]))
render_command(harness, "inspect adapter", safe_list(launch["inspect_command"]))
render_command(harness, "local launch", safe_list(launch["local_launch_command"]))
for warning in warnings {
let text = safe_string(warning, "")
if text != "" {
harness.stdio.println(" warning: " + text)
}
}
}
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_plan_failed",
message: "LoRA plan 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_PLAN_PAYLOAD_JSON", "")
if raw == "" {
harness.stdio.eprintln("internal error: HARN_MODELS_LORA_PLAN_PAYLOAD_JSON not set")
return 70
}
let report = try {
json_parse(raw)
} catch (e) {
harness.stdio.eprintln("internal error: failed to parse LoRA plan 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
}