okstra 0.34.1 → 0.36.1

package/runtime/python/okstra_ctl/render_final_report.py

@@ -35,11 +35,13 @@ import okstra_vendor  # noqa: F401 — side effect: sys.modules aliases
 from jinja2 import ChainableUndefined, Environment, FileSystemLoader
 from jinja2 import select_autoescape  # noqa: F401 — kept for future HTML use
 
+from okstra_ctl.i18n import I18nError, SUPPORTED_LANGS, load_dictionary, make_jinja_global
+
 
 DEFAULT_TEMPLATE_REL = ("templates", "reports", "final-report.template.md")
 
 
-class RenderError(RuntimeError):
+class FinalReportRenderError(RuntimeError):
     """Raised when the data.json cannot be rendered. Wraps jinja2 errors
     and IO errors with a single user-facing message so the CLI / Phase 6
     surface one consistent failure shape.
@@ -122,23 +124,59 @@ def _build_environment(template_dir: Path) -> Environment:
     return env
 
 
-def render(data: dict, *, template_path: Path) -> str:
+def resolve_report_language(data: dict, *, override: str | None) -> str:
+    """우선순위: override > data.meta.reportLanguage > 'en'."""
+    if override is not None:
+        candidate = override
+    else:
+        candidate = (data.get("meta") or {}).get("reportLanguage") or "en"
+    if candidate == "auto":
+        raise FinalReportRenderError(
+            "reportLanguage 'auto' must be resolved by the lead before "
+            "the renderer runs; the report-writer worker writes the "
+            "resolved 'en' or 'ko' into data.json.meta.reportLanguage."
+        )
+    if candidate not in SUPPORTED_LANGS:
+        raise FinalReportRenderError(
+            f"reportLanguage must be one of {SUPPORTED_LANGS}, got {candidate!r}"
+        )
+    return candidate
+
+
+def render(
+    data: dict,
+    *,
+    template_path: Path,
+    report_language: str | None = None,
+) -> str:
     """Render ``data`` through the Jinja2 ``template_path`` and return the
     final markdown as a string. Caller writes it to disk.
 
-    Raises ``RenderError`` on any template / IO / data structural failure
+    Raises ``FinalReportRenderError`` on any template / IO / data structural failure
     so the surface is one exception type rather than the broad jinja2
     hierarchy.
     """
     if not template_path.is_file():
-        raise RenderError(f"template not found: {template_path}")
+        raise FinalReportRenderError(f"template not found: {template_path}")
+
+    lang = resolve_report_language(data, override=report_language)
+    try:
+        dictionary = load_dictionary(lang)
+    except I18nError as exc:
+        raise FinalReportRenderError(str(exc)) from exc
 
     env = _build_environment(template_path.parent)
+    env.globals["t"] = make_jinja_global(dictionary)
+
     try:
         template = env.get_template(template_path.name)
         return template.render(**data)
+    except I18nError as exc:
+        raise FinalReportRenderError(
+            f"i18n lookup failed while rendering {template_path.name}: {exc}"
+        ) from exc
     except Exception as exc:  # jinja2.TemplateError, KeyError, etc.
-        raise RenderError(
+        raise FinalReportRenderError(
             f"render failed for template {template_path.name}: {exc}"
         ) from exc
 
@@ -152,7 +190,7 @@ def find_default_template(start: Path | None = None) -> Path:
          Repo root is detected by walking up from this file until a
          ``templates/reports/final-report.template.md`` exists.
 
-    Raises ``RenderError`` if neither path is present.
+    Raises ``FinalReportRenderError`` if neither path is present.
     """
     okstra_home = os.environ.get("OKSTRA_HOME")
     if okstra_home:
@@ -166,7 +204,7 @@ def find_default_template(start: Path | None = None) -> Path:
         if candidate.is_file():
             return candidate
 
-    raise RenderError(
+    raise FinalReportRenderError(
         "could not locate final-report.template.md. Set OKSTRA_HOME or "
         "run from a checkout that contains templates/reports/."
     )
@@ -177,6 +215,7 @@ def render_to_file(
     output_path: Path,
     *,
     template_path: Path | None = None,
+    report_language: str | None = None,
 ) -> int:
     """Read ``data_path`` (JSON), render through Jinja2, write to
     ``output_path``. Returns the number of bytes written.
@@ -185,14 +224,18 @@ def render_to_file(
     write never produces a half-corrupt final-report on disk.
     """
     if not data_path.is_file():
-        raise RenderError(f"data file not found: {data_path}")
+        raise FinalReportRenderError(f"data file not found: {data_path}")
     try:
         data = json.loads(data_path.read_text(encoding="utf-8"))
     except json.JSONDecodeError as exc:
-        raise RenderError(f"invalid JSON in {data_path}: {exc}") from exc
+        raise FinalReportRenderError(f"invalid JSON in {data_path}: {exc}") from exc
 
     resolved_template = template_path or find_default_template(data_path)
-    rendered = render(data, template_path=resolved_template)
+    rendered = render(
+        data,
+        template_path=resolved_template,
+        report_language=report_language,
+    )
 
     output_path.parent.mkdir(parents=True, exist_ok=True)
     tmp = output_path.with_suffix(output_path.suffix + f".tmp.{os.getpid()}")