bmad-module-skill-forge 1.9.0 → 2.0.0

package/src/skf-campaign/scripts/campaign-provenance.py

@@ -0,0 +1,247 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = ["pyyaml"]
+# ///
+"""Campaign Provenance — verify repo access and record commit SHAs for all targets.
+
+Replaces the step-04 prose that asked the LLM to string-munge each repo_url
+("handle trailing .git or slashes"), run `gh repo view` + `gh api commits/{ref}`
+per target, and aggregate failures across 15+ targets in-context. All of that
+is deterministic; doing it by hand is both token-expensive and a fragile-parse
+risk. This script owns the parse, the gh calls, and the aggregation, and — when
+every (or nearly every) target fails the same way — collapses the wall of
+near-identical errors into a single actionable root-cause hint instead of N
+independent failures.
+
+For each skill it resolves `{owner}/{repo}` from the brief's repo_url, picks the
+ref (the skill's pin, or the repo default branch), verifies access, and records
+the commit SHA.
+
+CLI:
+  uv run campaign-provenance.py --state-file <path> --brief-file <path>
+
+Output (JSON on stdout):
+  {
+    "results": [
+      {"name": "...", "repo_url": "...", "owner": "...", "repo": "...",
+       "ref": "...", "commit_sha": "..." | null,
+       "status": "accessible" | "inaccessible", "error": "..." | null}
+    ],
+    "all_accessible": bool,
+    "inaccessible_count": N,
+    "systemic_hint": "..." | null
+  }
+
+Exit codes:
+  0  all targets accessible
+  1  one or more targets inaccessible
+  2  error (missing files, bad YAML, gh not installed)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import subprocess  # noqa: S404 — invoking the user's authenticated `gh` CLI is the point
+import sys
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import yaml
+
+# A command runner returns (returncode, stdout, stderr). Injectable for tests.
+Runner = Callable[[List[str]], Tuple[int, str, str]]
+
+
+def _emit_error(message: str, code: str) -> None:
+    json.dump({"error": message, "code": code}, sys.stderr)
+    sys.stderr.write("\n")
+
+
+def _load_yaml(path: Path) -> Any:
+    with open(path, encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def parse_owner_repo(repo_url: str) -> Optional[Tuple[str, str]]:
+    """Extract (owner, repo) from a GitHub URL or `owner/repo` shorthand.
+
+    Tolerates trailing `.git`, trailing slashes, `git@` SSH form, and a bare
+    `owner/repo`. Returns None when no owner/repo pair can be recovered.
+    """
+    if not repo_url or not isinstance(repo_url, str):
+        return None
+    url = repo_url.strip().rstrip("/")
+    if url.endswith(".git"):
+        url = url[:-4]
+    # git@github.com:owner/repo
+    ssh = re.match(r"^git@[^:]+:(?P<owner>[^/]+)/(?P<repo>[^/]+)$", url)
+    if ssh:
+        return ssh.group("owner"), ssh.group("repo")
+    # https://host/owner/repo (take the last two path segments)
+    https = re.match(r"^[a-zA-Z]+://[^/]+/(?P<rest>.+)$", url)
+    rest = https.group("rest") if https else url
+    parts = [p for p in rest.split("/") if p]
+    if len(parts) >= 2:
+        return parts[-2], parts[-1]
+    return None
+
+
+def _default_runner(args: List[str]) -> Tuple[int, str, str]:
+    proc = subprocess.run(args, capture_output=True, text=True)  # noqa: S603
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+def _classify_error(stderr: str) -> str:
+    """Bucket a gh failure so systemic root causes can be detected."""
+    low = stderr.lower()
+    if "authentication" in low or "gh auth" in low or "not logged" in low or "401" in low:
+        return "auth"
+    if "could not resolve" in low or "network" in low or "timeout" in low or "dial tcp" in low:
+        return "network"
+    if "rate limit" in low or "403" in low:
+        return "rate-limit"
+    if "not found" in low or "404" in low:
+        return "not-found"
+    return "other"
+
+
+_SYSTEMIC_HINTS = {
+    "auth": "All targets failed authentication — run `gh auth status` / `gh auth login`, then `campaign resume`.",
+    "network": "All targets failed with network errors — check connectivity, then `campaign resume`.",
+    "rate-limit": "All targets hit GitHub rate limiting — wait for the limit to reset, then `campaign resume`.",
+}
+
+
+def run(state_file: str, brief_file: str, runner: Runner = _default_runner) -> int:
+    state_path = Path(state_file)
+    brief_path = Path(brief_file)
+
+    if not state_path.is_file():
+        _emit_error(f"State file not found: {state_file}", "STATE_NOT_FOUND")
+        return 2
+    if not brief_path.is_file():
+        _emit_error(f"Brief file not found: {brief_file}", "BRIEF_NOT_FOUND")
+        return 2
+    if shutil.which("gh") is None and runner is _default_runner:
+        _emit_error("GitHub CLI `gh` not found on PATH", "GH_NOT_FOUND")
+        return 2
+
+    try:
+        state = _load_yaml(state_path)
+    except Exception as exc:  # noqa: BLE001
+        _emit_error(f"Failed to parse state file: {exc}", "STATE_PARSE_ERROR")
+        return 2
+    try:
+        brief = _load_yaml(brief_path)
+    except Exception as exc:  # noqa: BLE001
+        _emit_error(f"Failed to parse brief file: {exc}", "BRIEF_PARSE_ERROR")
+        return 2
+
+    skills = state.get("skills", [])
+    if not isinstance(skills, list):
+        _emit_error("State file 'skills' is not an array", "INVALID_STATE")
+        return 2
+    targets = brief.get("targets", [])
+    if not isinstance(targets, list):
+        _emit_error("Brief file 'targets' is not an array", "INVALID_BRIEF")
+        return 2
+
+    name_to_repo: Dict[str, str] = {t["name"]: t["repo_url"] for t in targets}
+
+    results: List[Dict[str, Any]] = []
+    error_classes: List[str] = []
+
+    for skill in skills:
+        name = skill["name"]
+        repo_url = name_to_repo.get(name)
+        record: Dict[str, Any] = {
+            "name": name,
+            "repo_url": repo_url,
+            "owner": None,
+            "repo": None,
+            "ref": None,
+            "commit_sha": None,
+            "status": "inaccessible",
+            "error": None,
+        }
+        if repo_url is None:
+            record["error"] = f"Skill '{name}' has no repo_url in brief targets"
+            error_classes.append("other")
+            results.append(record)
+            continue
+
+        parsed = parse_owner_repo(repo_url)
+        if parsed is None:
+            record["error"] = f"Could not parse owner/repo from '{repo_url}'"
+            error_classes.append("other")
+            results.append(record)
+            continue
+        owner, repo = parsed
+        record["owner"], record["repo"] = owner, repo
+
+        rc, _out, err = runner(["gh", "repo", "view", f"{owner}/{repo}", "--json", "name"])
+        if rc != 0:
+            record["error"] = err.strip() or "gh repo view failed"
+            error_classes.append(_classify_error(err))
+            results.append(record)
+            continue
+
+        ref = skill.get("pin")
+        if not ref:
+            rc, out, err = runner(
+                ["gh", "repo", "view", f"{owner}/{repo}", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"]
+            )
+            if rc != 0:
+                record["error"] = err.strip() or "could not resolve default branch"
+                error_classes.append(_classify_error(err))
+                results.append(record)
+                continue
+            ref = out.strip()
+        record["ref"] = ref
+
+        rc, out, err = runner(["gh", "api", f"repos/{owner}/{repo}/commits/{ref}", "--jq", ".sha"])
+        if rc != 0:
+            record["error"] = err.strip() or f"could not resolve commit for ref '{ref}'"
+            error_classes.append(_classify_error(err))
+            results.append(record)
+            continue
+
+        record["commit_sha"] = out.strip()
+        record["status"] = "accessible"
+        results.append(record)
+
+    inaccessible = [r for r in results if r["status"] != "accessible"]
+    systemic_hint: Optional[str] = None
+    if inaccessible and len(inaccessible) == len(results):
+        # Every target failed — if they share a class, surface one root cause.
+        distinct = set(error_classes)
+        if len(distinct) == 1:
+            systemic_hint = _SYSTEMIC_HINTS.get(next(iter(distinct)))
+
+    output = {
+        "results": results,
+        "all_accessible": not inaccessible,
+        "inaccessible_count": len(inaccessible),
+        "systemic_hint": systemic_hint,
+    }
+    json.dump(output, sys.stdout, separators=(",", ":"))
+    sys.stdout.write("\n")
+    return 0 if not inaccessible else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="campaign-provenance",
+        description="Verify repo access and record commit SHAs for all campaign targets.",
+    )
+    parser.add_argument("--state-file", required=True, help="Path to _campaign-state.yaml")
+    parser.add_argument("--brief-file", required=True, help="Path to campaign-brief.yaml")
+    args = parser.parse_args(argv)
+    return run(args.state_file, args.brief_file)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/skf-campaign/scripts/campaign-render-kickoff.py

@@ -0,0 +1,158 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = ["pyyaml"]
+# ///
+"""Campaign Render Kickoff — fill the mechanical kickoff-template placeholders.
+
+step-05 emits a kickoff message per Tier-A skill. Most of its placeholders are
+direct field copies from state + brief (campaign name, stage, quality gate,
+skill identity, repo, pin, commit, the dependency-status table, the workaround
+list) — mechanical substitution that an LLM should not hand-perform 15× per
+campaign. This script renders those deterministically and leaves the three
+judgment slots untouched for the LLM to fill in context:
+
+  {{brief_summary}}        — concise summary of the brief target entry
+  {{persistent_facts}}     — campaign-wide facts resolved in On Activation
+  {{directive_content}}    — raw directive file content
+
+CLI:
+  uv run campaign-render-kickoff.py --state-file <p> --brief-file <p> \
+      --skill <name> --template <p> [--workarounds '<json-list>']
+
+Output: the rendered kickoff markdown on stdout (judgment slots preserved).
+
+Exit codes:
+  0  rendered
+  2  error (missing file, bad YAML, skill/target not found, bad --workarounds)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+# Placeholders this script intentionally leaves for the LLM to fill.
+JUDGMENT_SLOTS = ("{{brief_summary}}", "{{persistent_facts}}", "{{directive_content}}")
+
+
+def _err(message: str, code: str) -> int:
+    json.dump({"error": message, "code": code}, sys.stderr)
+    sys.stderr.write("\n")
+    return 2
+
+
+def _quality_gate_summary(qg: Dict[str, Any]) -> str:
+    return (
+        f"Hard: {qg.get('hard', 'N/A')} | "
+        f"Soft: {qg.get('soft_target', 'N/A')} (fallback: {qg.get('soft_fallback', 'N/A')})"
+    )
+
+
+def _dependency_status_table(skill: Dict[str, Any], skill_map: Dict[str, Dict[str, Any]]) -> str:
+    deps = skill.get("depends_on", []) or []
+    if not deps:
+        return "No dependencies."
+    rows = ["| Dependency | Status |", "|------------|--------|"]
+    for dep in deps:
+        status = skill_map.get(dep, {}).get("status", "unknown")
+        rows.append(f"| {dep} | {status} |")
+    return "\n".join(rows)
+
+
+def _workarounds_list(workarounds: List[str]) -> str:
+    if not workarounds:
+        return "None"
+    return "\n".join(f"- {w}" for w in workarounds)
+
+
+def render_kickoff(
+    state: Dict[str, Any],
+    brief: Dict[str, Any],
+    skill_name: str,
+    template: str,
+    workarounds: Optional[List[str]] = None,
+) -> str:
+    campaign = state.get("campaign", {})
+    skills = state.get("skills", [])
+    skill_map = {s["name"]: s for s in skills}
+    if skill_name not in skill_map:
+        raise KeyError(f"Skill '{skill_name}' not found in state")
+    skill = skill_map[skill_name]
+
+    targets = {t["name"]: t for t in brief.get("targets", [])}
+    repo_url = targets.get(skill_name, {}).get("repo_url", "")
+
+    wa = workarounds if workarounds is not None else (skill.get("workarounds_applied", []) or [])
+
+    mechanical = {
+        "{{campaign_name}}": str(campaign.get("name", "")),
+        "{{current_stage}}": str(campaign.get("current_stage", "")),
+        "{{quality_gate_summary}}": _quality_gate_summary(campaign.get("quality_gate", {})),
+        "{{skill_name}}": skill_name,
+        "{{skill_tier}}": str(skill.get("tier", "")),
+        "{{pin}}": skill.get("pin") or "latest",
+        "{{commit_sha}}": skill.get("commit_sha") or "unknown",
+        "{{repo_url}}": repo_url,
+        "{{workarounds_list}}": _workarounds_list(wa),
+        "{{dependency_status_table}}": _dependency_status_table(skill, skill_map),
+    }
+
+    out = template
+    for key, value in mechanical.items():
+        out = out.replace(key, value)
+    return out
+
+
+def run(state_file: str, brief_file: str, skill: str, template_file: str, workarounds_json: Optional[str]) -> int:
+    for label, p in (("State", state_file), ("Brief", brief_file), ("Template", template_file)):
+        if not Path(p).is_file():
+            return _err(f"{label} file not found: {p}", f"{label.upper()}_NOT_FOUND")
+
+    try:
+        state = yaml.safe_load(Path(state_file).read_text(encoding="utf-8"))
+        brief = yaml.safe_load(Path(brief_file).read_text(encoding="utf-8"))
+    except yaml.YAMLError as exc:
+        return _err(f"Failed to parse YAML: {exc}", "PARSE_ERROR")
+    template = Path(template_file).read_text(encoding="utf-8")
+
+    workarounds: Optional[List[str]] = None
+    if workarounds_json:
+        try:
+            workarounds = json.loads(workarounds_json)
+            if not isinstance(workarounds, list):
+                raise ValueError("not a list")
+        except ValueError as exc:
+            return _err(f"--workarounds must be a JSON list: {exc}", "BAD_WORKAROUNDS")
+
+    try:
+        rendered = render_kickoff(state, brief, skill, template, workarounds)
+    except KeyError as exc:
+        return _err(str(exc), "SKILL_NOT_FOUND")
+
+    sys.stdout.write(rendered)
+    if not rendered.endswith("\n"):
+        sys.stdout.write("\n")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="campaign-render-kickoff",
+        description="Render the mechanical placeholders in the campaign kickoff template.",
+    )
+    parser.add_argument("--state-file", required=True)
+    parser.add_argument("--brief-file", required=True)
+    parser.add_argument("--skill", required=True, help="skill name (must exist in state)")
+    parser.add_argument("--template", required=True, dest="template_file")
+    parser.add_argument("--workarounds", dest="workarounds_json", help="JSON list of applied workarounds")
+    args = parser.parse_args(argv)
+    return run(args.state_file, args.brief_file, args.skill, args.template_file, args.workarounds_json)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/skf-campaign/scripts/campaign-report.py

@@ -0,0 +1,249 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = ["pyyaml"]
+# ///
+"""Campaign Report — generate a markdown report from campaign state + template.
+
+CLI:
+  uv run campaign-report.py \
+      --state-file <path> --template-file <path> --output-file <path>
+
+Output (JSON on stdout):
+  {"status":"success","report_path":"...","skills_completed":N,"skills_failed":N,
+   "quality_scores":{"skill":score,...},"duration":"..."}
+
+Exit codes:
+  0  success
+  2  error (missing file, bad YAML, template error)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+
+def _emit_error(message: str, code: str) -> None:
+    json.dump({"error": message, "code": code}, sys.stderr)
+    sys.stderr.write("\n")
+
+
+def _load_yaml(path: Path) -> Any:
+    with open(path, encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def _parse_iso(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(value)
+    except (ValueError, TypeError):
+        return None
+
+
+def _format_duration(start: Optional[datetime], end: Optional[datetime]) -> str:
+    if not start or not end:
+        return "N/A"
+    delta = end - start
+    total_seconds = int(delta.total_seconds())
+    if total_seconds < 0:
+        return "N/A"
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    if hours > 0:
+        return f"{hours}h {minutes}m {seconds}s"
+    if minutes > 0:
+        return f"{minutes}m {seconds}s"
+    return f"{seconds}s"
+
+
+def _compute_aggregates(state: Dict[str, Any]) -> Dict[str, Any]:
+    campaign = state.get("campaign", {})
+    skills: List[Dict[str, Any]] = state.get("skills", [])
+
+    started_at_str = campaign.get("started_at", "")
+    last_updated_str = campaign.get("last_updated", "")
+    started_at = _parse_iso(started_at_str)
+    last_updated = _parse_iso(last_updated_str)
+
+    completed = [s for s in skills if s.get("status") == "completed"]
+    failed = [s for s in skills if s.get("status") == "failed"]
+    skipped = [s for s in skills if s.get("status") == "skipped"]
+
+    scores = [s["quality_score"] for s in completed if s.get("quality_score") is not None]
+    quality_min = min(scores) if scores else 0
+    quality_max = max(scores) if scores else 0
+    quality_avg = round(sum(scores) / len(scores), 1) if scores else 0
+
+    all_workarounds: List[str] = []
+    skills_with_wa = 0
+    for s in skills:
+        wa = s.get("workarounds_applied", []) or []
+        if wa:
+            skills_with_wa += 1
+            all_workarounds.extend(wa)
+
+    skills_table_rows = []
+    for s in skills:
+        wa = s.get("workarounds_applied", []) or []
+        skills_table_rows.append(
+            f"| {s.get('name', '')} "
+            f"| {s.get('tier', '')} "
+            f"| {s.get('status', '')} "
+            f"| {s.get('quality_score', 'N/A')} "
+            f"| {s.get('pin', 'N/A')} "
+            f"| {len(wa)} |"
+        )
+
+    quality_breakdown_rows = []
+    for s in completed:
+        qs = s.get("quality_score")
+        quality_breakdown_rows.append(f"- **{s['name']}**: {qs if qs is not None else 'N/A'}")
+
+    if not quality_breakdown_rows:
+        quality_breakdown_rows.append("No completed skills with quality scores.")
+
+    if all_workarounds:
+        workarounds_list_items = [f"- `{fp}`" for fp in all_workarounds]
+    else:
+        workarounds_list_items = ["No workarounds applied."]
+
+    duration_table_rows = []
+    for s in skills:
+        s_start = _parse_iso(s.get("started_at"))
+        s_end = _parse_iso(s.get("completed_at"))
+        s_start_str = s.get("started_at", "N/A") or "N/A"
+        s_end_str = s.get("completed_at", "N/A") or "N/A"
+        dur = _format_duration(s_start, s_end)
+        duration_table_rows.append(f"| {s.get('name', '')} | {s_start_str} | {s_end_str} | {dur} |")
+
+    failed_skipped_lines = []
+    if failed:
+        failed_skipped_lines.append("### Failed Skills\n")
+        for s in failed:
+            failed_skipped_lines.append(f"- **{s['name']}** (Tier {s.get('tier', '?')})")
+    if skipped:
+        failed_skipped_lines.append("\n### Skipped Skills\n")
+        for s in skipped:
+            failed_skipped_lines.append(f"- **{s['name']}** (Tier {s.get('tier', '?')})")
+    if not failed and not skipped:
+        if skills:
+            failed_skipped_lines.append("All skills completed successfully.")
+        else:
+            failed_skipped_lines.append("No skills in campaign.")
+
+    quality_gate = campaign.get("quality_gate", {})
+
+    return {
+        "campaign_name": campaign.get("name", ""),
+        "started_at": started_at_str or "N/A",
+        "completed_at": last_updated_str or "N/A",
+        "duration": _format_duration(started_at, last_updated),
+        "quality_gate_hard": quality_gate.get("hard", "N/A"),
+        "quality_gate_soft_target": str(quality_gate.get("soft_target", "N/A")),
+        "quality_gate_soft_fallback": str(quality_gate.get("soft_fallback", "N/A")),
+        "skills_completed": str(len(completed)),
+        "skills_failed": str(len(failed)),
+        "skills_skipped": str(len(skipped)),
+        "skills_table": "\n".join(skills_table_rows),
+        "quality_min": str(quality_min),
+        "quality_max": str(quality_max),
+        "quality_avg": str(quality_avg),
+        "quality_breakdown": "\n".join(quality_breakdown_rows),
+        "total_workarounds": str(len(all_workarounds)),
+        "skills_with_workarounds": str(skills_with_wa),
+        "workarounds_list": "\n".join(workarounds_list_items),
+        "duration_table": "\n".join(duration_table_rows),
+        "failed_skipped_section": "\n".join(failed_skipped_lines),
+    }
+
+
+def run(state_file: str, template_file: str, output_file: str) -> int:
+    state_path = Path(state_file)
+    template_path = Path(template_file)
+    output_path = Path(output_file)
+
+    if not state_path.is_file():
+        _emit_error(f"State file not found: {state_file}", "STATE_NOT_FOUND")
+        return 2
+
+    if not template_path.is_file():
+        _emit_error(f"Template file not found: {template_file}", "TEMPLATE_NOT_FOUND")
+        return 2
+
+    try:
+        state = _load_yaml(state_path)
+    except Exception as exc:
+        _emit_error(f"Failed to parse state file: {exc}", "STATE_PARSE_ERROR")
+        return 2
+
+    if not isinstance(state, dict):
+        _emit_error("State file root is not a mapping", "INVALID_STATE")
+        return 2
+
+    try:
+        template = template_path.read_text(encoding="utf-8")
+    except Exception as exc:
+        _emit_error(f"Failed to read template file: {exc}", "TEMPLATE_READ_ERROR")
+        return 2
+
+    try:
+        aggregates = _compute_aggregates(state)
+    except Exception as exc:
+        _emit_error(f"Failed to compute report aggregates: {exc}", "AGGREGATE_ERROR")
+        return 2
+
+    report = template
+    for key, value in aggregates.items():
+        report = report.replace("{{" + key + "}}", value)
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        output_path.write_text(report, encoding="utf-8")
+    except Exception as exc:
+        _emit_error(f"Failed to write report: {exc}", "WRITE_ERROR")
+        return 2
+
+    skills = state.get("skills", [])
+    completed_count = sum(1 for s in skills if s.get("status") == "completed")
+    failed_count = sum(1 for s in skills if s.get("status") == "failed")
+    quality_scores = {
+        s["name"]: s["quality_score"]
+        for s in skills
+        if s.get("status") == "completed" and s.get("quality_score") is not None
+    }
+
+    result = {
+        "status": "success",
+        "report_path": output_path.as_posix(),
+        "skills_completed": completed_count,
+        "skills_failed": failed_count,
+        "quality_scores": quality_scores,
+        "duration": aggregates["duration"],
+    }
+    json.dump(result, sys.stdout, separators=(",", ":"))
+    sys.stdout.write("\n")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Generate a campaign report from state and template.",
+    )
+    parser.add_argument("--state-file", required=True, help="Path to _campaign-state.yaml")
+    parser.add_argument("--template-file", required=True, help="Path to campaign-report-template.md")
+    parser.add_argument("--output-file", required=True, help="Path to write the generated report")
+    args = parser.parse_args()
+    return run(args.state_file, args.template_file, args.output_file)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())