aiblueprint-cli 1.4.100 → 1.4.102

package/README.md

@@ -151,7 +151,6 @@ npx skills add Melvynx/aiblueprint --skill skill-manager
 | `environments-manager` | Set up per-worktree agent environments |
 | `oneshot` | Implement one focused change quickly |
 | `prompt` | Create minimalist SVG logo variations |
-| `prompt-creator` | Expert prompt engineering |
 | `rules-manager` | Create and maintain agent rule files |
 | `skill-manager` | Manage skills and rules across Claude Code, Codex, and Cursor |
 | `tools` | AIBlueprint tools and libraries reference |

package/agents-config/skills/audit-memories/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: audit-memories
+description: Manual-only audit and cleanup of agent-facing Markdown inside the current project. Run only from an explicit `$audit-memories` or `/audit-memories` user command; never select it implicitly.
+argument-hint: "[audit|clean]"
+disable-model-invocation: true
+user-invocable: true
+---
+
+# Audit Project Memories
+
+Treat agent instructions, rules, skills, plans, task traces, and outputs inside the current project as its agent memory. Compare them with current project truth, then remove noise without destroying durable guidance.
+
+## Invocation guard
+
+Proceed only when the user explicitly invokes `$audit-memories` or `/audit-memories`. An OpenCode command may satisfy this guard by explicitly stating that the user invoked `/audit-memories` before injecting this file.
+
+Supported actions:
+
+- `$audit-memories audit`: exhaustive read-only audit. This is the default action when only `$audit-memories` is supplied.
+- `$audit-memories clean`: run or refresh the exhaustive audit, then apply justified local cleanup.
+- `/audit-memories audit` and `/audit-memories clean`: equivalent manual commands in clients that use slash-command syntax.
+
+Do not read or modify `~/.codex/memories`. Do not classify product documentation, public docs, README files, changelogs, or general project plans. They may be read only as truth evidence when an agent document references them.
+
+## Hard boundaries
+
+- Resolve the project root from the current working directory. Never silently switch to another checkout.
+- Read the nearest applicable `AGENTS.md`, `CLAUDE.md`, and repository rules before auditing.
+- Preserve unrelated dirty-tree changes. Record `git status --short` before and after.
+- Never inspect secret values. Compare environment-variable names through examples, schemas, and code only.
+- Never use `rm -rf`. Use `trash` for approved file removal.
+- Use `apply_patch` for textual edits. Use formatters only for mechanical normalization.
+- Do not infer deployed truth from local code. Label provider/runtime claims `NOT VERIFIED` unless the audit explicitly checks the live system.
+- Do not delete instruction files, security guidance, migration procedures, incident runbooks, or destructive-operation safeguards merely because they are old or rarely linked.
+
+## Action: audit
+
+### 1. Inventory every agent-facing Markdown file
+
+Run:
+
+```bash
+python3 ~/.agents/skills/audit-memories/scripts/inventory_project_markdown.py \
+  --root "$PWD" \
+  --format json
+```
+
+Include only:
+
+- `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, and equivalent agent entrypoints;
+- `.agents/**/*.md`, `.claude/**/*.md`, and `.cursor/**/*.{md,mdc}`;
+- `.github/copilot-instructions.md` and `.github/instructions/**/*.md`;
+- project skill files under `skills/**/SKILL.md` or `.agents/skills/**`.
+
+This intentionally includes agent-generated plans, task traces, and output folders because they are prime cleanup candidates. Exclude public/local documentation such as `content/docs`, normal README files, product specs, and application changelogs from classification.
+
+The byte-level ledger must show `visited == eligible`. It is not a semantic audit by itself.
+
+### 2. Build the project truth map
+
+Inspect current primary evidence before classifying documents:
+
+1. repository instructions and package/workspace manifests;
+2. source tree, routes, exported APIs, schemas, migrations, and configuration;
+3. tests and CI workflows;
+4. current Git history only when a document makes a historical claim;
+5. live provider/runtime state only when explicitly requested and safely accessible.
+
+Start with `rg --files`, `package.json` or equivalent manifests, key configs, and the files referenced by Markdown. Follow repository instructions about required reading. Use targeted searches rather than loading the entire source tree blindly.
+
+Truth priority:
+
+```text
+explicit current user instruction
+> current code/config/schema
+> current tests and CI contracts
+> verified provider/runtime read-back
+> Markdown claims
+> historical memory
+```
+
+### 3. Review files one by one
+
+Read every eligible agent-facing Markdown file. Sampling is not completion.
+
+For more than 30 files, split the exact manifest into disjoint batches of 10–20. Use parallel subagents when available. Give each worker the shared truth map plus exact Markdown paths and read-only boundaries. Require one result row per path; verify that batch union equals the manifest with no duplicates.
+
+For each file, record:
+
+- purpose and intended audience;
+- whether referenced paths, commands, APIs, routes, names, versions, statuses, and architecture match current evidence;
+- overlap with other Markdown files;
+- broken local links and missing referenced files;
+- historical value and operational risk;
+- evidence paths and line numbers;
+- verdict: `KEEP`, `UPDATE`, `MERGE`, `ARCHIVE`, `DELETE`, or `VERIFY`.
+
+For important claims, use:
+
+- `VERIFIED`: directly supported by current local evidence;
+- `CONTRADICTED`: current evidence disproves it;
+- `NOT VERIFIED`: needs external/runtime evidence;
+- `HISTORICAL`: intentionally describes an old state;
+- `OPINION`: product/design intent, not a factual implementation claim.
+
+Load [cleanup-rubric.md](references/cleanup-rubric.md) before classification.
+
+### 4. Produce the audit report
+
+Return:
+
+- project root and Git status boundary;
+- files eligible, byte-visited, semantically reviewed, skipped, and failed;
+- current lines/bytes and projected post-clean totals;
+- verdict counts and defensible removal percentage;
+- one concise row per agent-facing Markdown file;
+- contradiction table with exact document and truth-source lines;
+- duplicate/merge clusters and canonical destination;
+- broken local links;
+- protected documents and why they must survive;
+- claims marked `NOT VERIFIED`.
+
+Do not create another report Markdown inside the project unless the user explicitly asks for a durable report.
+
+## Action: clean
+
+Run the complete audit first unless a still-current exhaustive audit exists for the same Git tree. Recheck hashes and `git status`; refresh changed files.
+
+Apply verdicts as follows:
+
+- `KEEP`: no change.
+- `UPDATE`: make the smallest accurate edit and preserve useful history.
+- `MERGE`: move unique knowledge into the declared canonical file, update inbound links, then `trash` the redundant file.
+- `ARCHIVE`: use only when historical value is real and the repository already has an archive convention.
+- `DELETE`: `trash` only after proving the file is redundant, contradicted without historical value, generated noise, or obsolete execution residue.
+- `VERIFY`: leave unchanged unless the required evidence is obtained.
+
+Before modifying any file, obey repository-specific read requirements. If the worktree is dirty, never overwrite overlapping user changes; downgrade that action to `BLOCKED` and continue with disjoint files.
+
+After edits:
+
+1. rerun the inventory and local-link checks;
+2. search for references to removed or renamed files;
+3. run proportionate repository validation through its required supervisor;
+4. inspect the final diff and confirm no non-Markdown behavior changed unintentionally;
+5. report exact files updated, merged, archived, trashed, blocked, and untouched.
+
+Do not commit or push unless explicitly requested.
+
+## Completion criteria
+
+Complete `audit` only when every eligible Markdown file has one semantic verdict and evidence.
+
+Complete `clean` only when:
+
+- the exhaustive ledger still matches the current tree;
+- every applied deletion has a proven canonical replacement or explicit no-value rationale;
+- links and references are repaired;
+- protected operational knowledge remains accessible;
+- validation results and blockers are reported separately;
+- the final dirty tree contains no accidental out-of-scope edits.

package/agents-config/skills/audit-memories/agents/openai.yaml

@@ -0,0 +1,10 @@
+interface:
+  display_name: "Audit Agent Memories"
+  short_description: "Audit and clean project agent documentation"
+  icon_small: "./assets/codex-icon.svg"
+  icon_large: "./assets/codex-icon.svg"
+  brand_color: "#5F3DC4"
+  default_prompt: "Use $audit-memories audit to compare every agent instruction, rule, skill, and task trace in this project with the current code and configuration."
+
+policy:
+  allow_implicit_invocation: false

package/agents-config/skills/audit-memories/assets/codex-icon.svg

@@ -0,0 +1,19 @@
+<svg role="img" aria-label="audit memories skill icon"
+  xmlns="http://www.w3.org/2000/svg"
+  width="128"
+  height="128"
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width="2"
+  stroke-linecap="round"
+  stroke-linejoin="round"
+>
+  <ellipse cx="9" cy="5" rx="6" ry="3" />
+  <path d="M3 5v8c0 1.7 2.7 3 6 3" />
+  <path d="M15 5v5" />
+  <path d="M3 9c0 1.7 2.7 3 6 3 2 0 3.8-.5 4.9-1.3" />
+  <circle cx="16" cy="16" r="4" />
+  <path d="m19 19 2 2" />
+  <path d="m14.5 16 1 1 2-2" />
+</svg>

package/agents-config/skills/audit-memories/references/cleanup-rubric.md

@@ -0,0 +1,105 @@
+# Project agent-memory cleanup rubric
+
+Inventory is not semantic review. Classify every eligible agent instruction, rule, skill, command, task trace, plan, and output against current project evidence. Public documentation and normal README files are evidence sources, not cleanup targets.
+
+## Evidence checks
+
+Verify claims with the closest primary source:
+
+| Markdown claim | Primary local evidence |
+| --- | --- |
+| Commands and scripts | package/workspace manifest and executable scripts |
+| Paths and filenames | current filesystem and imports |
+| Routes and APIs | route files, handlers, schemas, generated API contracts |
+| Data model | schema and migrations |
+| Architecture | source imports, boundaries, configuration, tests |
+| Environment variables | example files, validators, and code references; never secret values |
+| Feature status | current implementation and tests |
+| Deployment/runtime status | live provider read-back, otherwise `NOT VERIFIED` |
+| Historical decision | Git history, ADR, migration, or dated plan context |
+
+## Score
+
+Score each agent-memory document:
+
+| Dimension | 0 | 1 | 2 | 3 |
+| --- | --- | --- | --- | --- |
+| Current utility | none | occasional | useful | operationally critical |
+| Accuracy | contradicted | mostly stale | mixed | verified/current |
+| Uniqueness | exact duplicate | mostly repeated | partly unique | canonical |
+| Discoverability | orphaned | weakly linked | findable | canonical entry point |
+| Historical value | none | weak | useful | required audit trail |
+
+Penalties:
+
+- −3 for dangerous commands or guidance contradicted by current code.
+- −2 for pretending an old plan/status is current.
+- −2 for a redundant file whose unique content fits in the canonical document.
+- −1 for broken links, stale paths, temporary identifiers, or execution narration.
+
+Interpretation:
+
+- 11–15: `KEEP`, with small corrections if needed.
+- 7–10: `UPDATE` or `MERGE`.
+- 4–6: `ARCHIVE` only when history matters; otherwise `DELETE`.
+- 0–3: `DELETE`.
+- External truth required: `VERIFY`, regardless of score.
+
+The score informs judgment; it never overrides a safety boundary.
+
+## Keep
+
+- Root agent onboarding and instruction documentation that still matches the project.
+- Current architecture, API, schema, development, and operational guidance.
+- AGENTS/CLAUDE/rules/skills that encode active agent behavior.
+- Security, billing, sending, migration, recovery, and production runbooks.
+- ADRs and completed plans that explain a still-relevant non-obvious constraint.
+- Product intent clearly labeled as intent rather than implementation truth.
+
+## Update
+
+- A canonical agent document with stale commands, paths, names, or architecture.
+- A useful runbook with drifted implementation details.
+- A plan that should be labeled completed, superseded, or historical.
+- A document mixing verified local facts with unverified production claims.
+
+## Merge
+
+- Multiple entry points explaining the same workflow.
+- A temporary analysis whose unique conclusion belongs in README, architecture, ADR, or runbook.
+- Repeated command lists that should derive from one canonical source.
+
+Before merging, list every unique fact from the source and its destination. Update inbound links before trashing the source.
+
+## Archive
+
+Archive only if the repository already has a discoverable archive convention and the document retains real historical or compliance value. Archiving junk is not cleanup.
+
+## Delete
+
+- Empty, generated, accidental, or abandoned Markdown residue.
+- Fully superseded implementation plans with no unique decision history.
+- Point-in-time reports, pasted logs, temporary TODO dumps, or completed execution checklists with no reusable lesson.
+- Exact duplicates and near-duplicates after preserving unique content.
+- Documents describing removed code as current and offering no useful historical context.
+- Unreferenced analyses whose conclusions are already canonical elsewhere.
+
+## Protected deletion questions
+
+Before `DELETE`, answer all of these with evidence:
+
+1. Is every unique fact obsolete, duplicated, or valueless?
+2. Could deletion hide a security, billing, migration, recovery, sending, or production constraint?
+3. Are inbound links and references known?
+4. Is there a canonical replacement when readers still need the topic?
+5. Does Git preserve recoverability, and will `trash` be used locally?
+
+If any answer is unclear, choose `UPDATE`, `MERGE`, or `VERIFY`.
+
+## Required result row
+
+```text
+path | lines | purpose | truth status | overlap | verdict | evidence | reason
+```
+
+Never mark the audit complete with sampled rows or project-level guesses.

package/agents-config/skills/audit-memories/scripts/inventory_project_markdown.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""Read-only inventory of agent-facing Markdown inside a project."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import subprocess
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+from urllib.parse import unquote
+
+
+EXCLUDED_DIRS = {
+    ".git",
+    ".next",
+    ".turbo",
+    ".cache",
+    "node_modules",
+    "vendor",
+    "dist",
+    "build",
+    "coverage",
+    "tmp",
+    "temp",
+    "__pycache__",
+}
+MARKDOWN_SUFFIXES = {".md", ".mdx", ".mdc"}
+AGENT_ROOTS = {".agents", ".claude", ".cursor"}
+AGENT_ENTRYPOINTS = {"agents.md", "claude.md", "gemini.md", ".cursorrules"}
+LINK_RE = re.compile(r"!?\[[^\]]*\]\(([^)]+)\)")
+HEADING_RE = re.compile(r"^#{1,6}\s+", re.MULTILINE)
+STATUS_RE = re.compile(
+    r"\b(?:todo|fixme|wip|draft|deprecated|obsolete|superseded|completed|done|current|production)\b",
+    re.IGNORECASE,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=Path.cwd())
+    parser.add_argument("--scope", default="", help="Optional case-insensitive path/content filter")
+    parser.add_argument("--format", choices=("json", "markdown"), default="json")
+    parser.add_argument("--output", type=Path, help="Optional report path outside the project root")
+    return parser.parse_args()
+
+
+def project_root(value: Path) -> Path:
+    root = value.expanduser().resolve()
+    result = subprocess.run(
+        ["git", "-C", str(root), "rev-parse", "--show-toplevel"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        resolved = Path(result.stdout.strip()).resolve()
+        if resolved == root or resolved in root.parents:
+            return resolved
+    return root
+
+
+def tracked_paths(root: Path) -> tuple[set[str], set[str]]:
+    tracked = subprocess.run(
+        ["git", "-C", str(root), "ls-files"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    untracked = subprocess.run(
+        ["git", "-C", str(root), "ls-files", "--others", "--exclude-standard"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return set(tracked.stdout.splitlines()), set(untracked.stdout.splitlines())
+
+
+def markdown_files(root: Path) -> tuple[list[Path], list[dict[str, str]]]:
+    files: list[Path] = []
+    skipped: list[dict[str, str]] = []
+    for directory, dirnames, filenames in os.walk(root, followlinks=False):
+        current = Path(directory)
+        kept: list[str] = []
+        for dirname in sorted(dirnames):
+            child = current / dirname
+            relative = child.relative_to(root).as_posix()
+            if dirname in EXCLUDED_DIRS:
+                skipped.append({"path": relative + "/", "reason": "generated or control directory"})
+            elif child.is_symlink():
+                skipped.append({"path": relative, "reason": "symlink directory outside traversal"})
+            else:
+                kept.append(dirname)
+        dirnames[:] = kept
+
+        for filename in sorted(filenames):
+            path = current / filename
+            relative_path = path.relative_to(root)
+            if not is_agent_markdown(relative_path):
+                continue
+            relative = relative_path.as_posix()
+            if path.is_symlink():
+                skipped.append({"path": relative, "reason": "symlink file"})
+            else:
+                files.append(path)
+    return sorted(files), skipped
+
+
+def is_agent_markdown(relative: Path) -> bool:
+    parts = tuple(part.lower() for part in relative.parts)
+    name = relative.name.lower()
+    suffix = relative.suffix.lower()
+    if name in AGENT_ENTRYPOINTS:
+        return True
+    if parts and parts[0] in AGENT_ROOTS and suffix in MARKDOWN_SUFFIXES:
+        return True
+    if parts[:2] == (".github", "copilot-instructions.md"):
+        return True
+    if len(parts) >= 3 and parts[:2] == (".github", "instructions") and suffix in MARKDOWN_SUFFIXES:
+        return True
+    return name == "skill.md" and "skills" in parts
+
+
+def document_kind(relative: Path) -> str:
+    name = relative.name.lower()
+    parts = {part.lower() for part in relative.parts}
+    if name in AGENT_ENTRYPOINTS or "rules" in parts or "skills" in parts:
+        return "instruction"
+    if "commands" in parts:
+        return "command"
+    if "plans" in parts or "tasks" in parts or "ralph-tasks" in parts:
+        return "plan_or_task"
+    if "output" in parts:
+        return "agent_output"
+    if "docs" in parts:
+        return "agent_reference"
+    if "styles" in parts:
+        return "agent_style"
+    return "agent_other"
+
+
+def local_target(root: Path, source: Path, raw_target: str) -> tuple[str, bool | None, str] | None:
+    target = raw_target.strip().split(maxsplit=1)[0].strip("<>")
+    if not target or target.startswith(("#", "http://", "https://", "mailto:", "tel:", "data:")):
+        return None
+    if "{{" in target or "}}" in target:
+        return None
+    target = unquote(target.split("#", 1)[0].split("?", 1)[0])
+    if not target:
+        return None
+    if target.startswith("/"):
+        return target, None, "application_route"
+    resolved = source.parent / target
+    resolved = resolved.resolve()
+    try:
+        relative = resolved.relative_to(root).as_posix()
+    except ValueError:
+        return str(resolved), False, "outside_project"
+    return relative, resolved.exists(), "project_file"
+
+
+def inspect_file(path: Path, root: Path, tracked: set[str], untracked: set[str], scope: str) -> tuple[dict[str, Any], str]:
+    raw = path.read_bytes()
+    text = raw.decode("utf-8", errors="replace")
+    relative = path.relative_to(root)
+    relative_text = relative.as_posix()
+    links: list[dict[str, Any]] = []
+    for match in LINK_RE.finditer(text):
+        checked = local_target(root, path, match.group(1))
+        if checked is None:
+            continue
+        target, exists, kind = checked
+        links.append(
+            {
+                "target": target,
+                "exists": exists,
+                "kind": kind,
+                "line": text.count("\n", 0, match.start()) + 1,
+            }
+        )
+
+    normalized = re.sub(r"\s+", " ", text).strip().lower().encode("utf-8")
+    record = {
+        "path": relative_text,
+        "kind": document_kind(relative),
+        "git_state": "tracked" if relative_text in tracked else "untracked" if relative_text in untracked else "ignored_or_external",
+        "bytes": len(raw),
+        "lines": text.count("\n") + (1 if text and not text.endswith("\n") else 0),
+        "sha256": hashlib.sha256(raw).hexdigest(),
+        "normalized_sha256": hashlib.sha256(normalized).hexdigest(),
+        "modified_utc": datetime.fromtimestamp(path.stat().st_mtime, timezone.utc).isoformat(),
+        "headings": len(HEADING_RE.findall(text)),
+        "local_links": links,
+        "broken_local_links": [
+            link for link in links if link["kind"] in {"project_file", "outside_project"} and link["exists"] is False
+        ],
+        "application_route_links": [link for link in links if link["kind"] == "application_route"],
+        "status_markers": sorted({match.group(0).lower() for match in STATUS_RE.finditer(text)}),
+        "scope_hits": text.lower().count(scope.lower()) if scope else None,
+    }
+    return record, text
+
+
+def build_report(root: Path, scope: str) -> dict[str, Any]:
+    paths, skipped = markdown_files(root)
+    tracked, untracked = tracked_paths(root)
+    records: list[dict[str, Any]] = []
+    failures: list[dict[str, str]] = []
+    hashes: defaultdict[str, list[str]] = defaultdict(list)
+    normalized_hashes: defaultdict[str, list[str]] = defaultdict(list)
+
+    for path in paths:
+        relative = path.relative_to(root).as_posix()
+        try:
+            record, _ = inspect_file(path, root, tracked, untracked, scope)
+            records.append(record)
+            hashes[record["sha256"]].append(relative)
+            normalized_hashes[record["normalized_sha256"]].append(relative)
+        except OSError as error:
+            failures.append({"path": relative, "reason": str(error)})
+
+    kind_counts = Counter(record["kind"] for record in records)
+    matching = [
+        record["path"]
+        for record in records
+        if not scope or scope.lower() in record["path"].lower() or bool(record["scope_hits"])
+    ]
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "root": str(root),
+        "scope": scope or None,
+        "ledger": {
+            "eligible": len(paths),
+            "visited": len(records),
+            "skipped": skipped,
+            "failed": failures,
+            "complete": len(records) + len(failures) == len(paths),
+        },
+        "totals": {
+            "files": len(records),
+            "lines": sum(record["lines"] for record in records),
+            "bytes": sum(record["bytes"] for record in records),
+            "by_kind": dict(sorted(kind_counts.items())),
+        },
+        "scope_matching_files": matching,
+        "exact_duplicate_groups": [group for group in hashes.values() if len(group) > 1],
+        "normalized_duplicate_groups": [group for group in normalized_hashes.values() if len(group) > 1],
+        "broken_local_links": [
+            {"path": record["path"], "links": record["broken_local_links"]}
+            for record in records
+            if record["broken_local_links"]
+        ],
+        "application_route_links": [
+            {"path": record["path"], "links": record["application_route_links"]}
+            for record in records
+            if record["application_route_links"]
+        ],
+        "files": records,
+    }
+
+
+def markdown_report(report: dict[str, Any]) -> str:
+    ledger = report["ledger"]
+    totals = report["totals"]
+    lines = [
+        "# Project agent-memory inventory",
+        "",
+        f"- Root: `{report['root']}`",
+        f"- Visited: {ledger['visited']} / {ledger['eligible']}",
+        f"- Failed: {len(ledger['failed'])}",
+        f"- Total: {totals['files']} files, {totals['lines']} lines, {totals['bytes']} bytes",
+        f"- Exact duplicate groups: {len(report['exact_duplicate_groups'])}",
+        f"- Broken-link files: {len(report['broken_local_links'])}",
+        "",
+        "| Path | Kind | Git | Lines | Broken links |",
+        "| --- | --- | --- | ---: | ---: |",
+    ]
+    for record in report["files"]:
+        lines.append(
+            f"| `{record['path']}` | {record['kind']} | {record['git_state']} | "
+            f"{record['lines']} | {len(record['broken_local_links'])} |"
+        )
+    return "\n".join(lines) + "\n"
+
+
+def main() -> None:
+    args = parse_args()
+    root = project_root(args.root)
+    report = build_report(root, args.scope.strip())
+    rendered = json.dumps(report, indent=2, ensure_ascii=False) if args.format == "json" else markdown_report(report)
+    if args.output:
+        output = args.output.expanduser().resolve()
+        if output == root or root in output.parents:
+            raise SystemExit("Refusing to write an audit report inside the project without explicit agent handling")
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(rendered + ("\n" if args.format == "json" else ""), encoding="utf-8")
+    else:
+        print(rendered)
+
+
+if __name__ == "__main__":
+    main()