ai-forge-cli 0.1.2__tar.gz

ai_forge_cli-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William James
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

ai_forge_cli-0.1.2/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: ai-forge-cli
+Version: 0.1.2
+Summary: Context walker for the Forge L0-L5 spec system
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file

ai_forge_cli-0.1.2/README.md

@@ -0,0 +1,286 @@
+<div align="center">
+
+```
+███████╗ ██████╗ ██████╗  ██████╗ ███████╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝
+█████╗  ██║   ██║██████╔╝██║  ███╗█████╗  
+██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝  
+██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗
+╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝
+```
+
+**Spec-driven agent development.**
+The agent drives the interview. The specs drive the code.
+
+[![CI](https://github.com/GreyFlames07/forge/actions/workflows/ci.yml/badge.svg)](https://github.com/GreyFlames07/forge/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+</div>
+
+---
+
+## What it is
+
+A six-layer YAML spec system, a Python CLI for context assembly, and **ten agent skills** that take a human from a vague product idea to working, audited, hardened, validated code — with the agent asking questions and the human answering, not the reverse.
+
+Built on the premise that **people explain systems well under questioning but poorly when cold-prompted**. forge inverts the default "human prompts agent → agent implements" loop into "agent interviews human → structured spec emerges → agent implements from spec".
+
+Runs in **Claude Code**, **OpenAI Codex CLI**, and any **agentskills.io-compatible client** (VS Code Copilot, Cursor).
+
+---
+
+## The pipeline
+
+```
+  idea
+    ↓
+  forge-discover    →  foundation       (modules, L0 vocab, L1 conventions, L5 posture)
+    ↓
+  forge-decompose   →  atom inventory   (stub files, module populated, entry-point hints)
+    ↓
+  forge-atom        →  complete specs   (one atom at a time — three interview shapes)
+    ↓
+  forge-compose     →  L4 composition   (flows + journeys from completed atoms)
+    ↓
+  forge-audit       →  quality gate     (seven audit passes, severity-ranked findings)
+    ↓
+  forge-armour      →  security hardening (trust model, policies, abuse-case review)
+    ↓
+  forge-implement   →  code + tests     (parallel subagents, test-before-impl isolation)
+    ↓
+  forge-validate    →  validation report (static analysis, test mapping, live interaction probes)
+    ↓
+  working system
+```
+
+Each skill is a markdown directive file (agent-facing) plus a longer framework doc (human reference). Each uses the `forge` CLI to sense project state and load context — agents don't inline spec content in prompts.
+
+---
+
+## Install
+
+### Fresh machine — four commands
+
+```bash
+git clone https://github.com/GreyFlames07/forge.git
+cd forge
+uv venv --python 3.13 .venv && uv pip install -e . pytest
+./scripts/install-skills.sh install
+```
+
+This wires the `forge` binary into `~/.local/bin/` and symlinks the ten skills into `~/.claude/skills/`, `~/.codex/skills/`, and `~/.agents/skills/` — discoverable by every supported client.
+
+### Verify
+
+```
+forge --version           # shows installed forge version
+forge --help              # shows: init, update, context, list, inspect, find
+.venv/bin/pytest          # 54 passed
+```
+
+### Requirements
+
+| | |
+|---|---|
+| Python | ≥ 3.13 |
+| Package manager | [`uv`](https://docs.astral.sh/uv/) recommended; pip works |
+| One agent client | Claude Code, Codex CLI, or an agentskills.io-compatible client |
+
+If `forge: command not found`: add `~/.local/bin` to PATH.
+
+```bash
+export PATH="$HOME/.local/bin:$PATH"  # add to ~/.zshrc to persist
+```
+
+---
+
+## Quick start
+
+Bootstrap a new project in any empty directory:
+
+```bash
+mkdir ~/my-idea && cd ~/my-idea
+forge init
+```
+
+```
+    ✦  INITIALISING FORGE
+    ▸ Forge init in /Users/you/my-idea
+
+      ✓ .forge/
+      ✓ 6 spec subdirectories
+      ✓ 12 schema templates → .forge/templates/
+      ✓ 30/30 skill symlinks → .claude/skills/, .codex/skills/, .agents/skills/
+
+    ───── Next steps ─────
+
+      Set the spec dir (add to your shell rc to persist):
+        export FORGE_SPEC_DIR="/Users/you/my-idea/.forge"
+
+      Start a session in this directory:
+        claude │ codex │ any agentskills.io client
+
+      Trigger a forge skill with a natural-language prompt:
+        "I want to build a tool that does X"
+        "Decompose the PAY module into atoms"
+        "Audit the specs before implementation"
+        "Harden the specs for security before implementation"
+```
+
+Open an agent session in that directory and describe your idea in natural language. The relevant skill activates; the interview begins.
+
+---
+
+## CLI
+
+| Command | Purpose |
+|---|---|
+| `forge init` | Scaffold a new project (`.forge/` + skill symlinks + schema templates) |
+| `forge update` | Refresh init-managed project assets to the current Forge version |
+| `forge --version` | Print the installed Forge CLI version |
+| `forge list [--kind K]` | Enumerate entities in the spec dir |
+| `forge inspect <id>` | Lightweight metadata probe |
+| `forge context <id>` | Full implementation-ready bundle for an entity |
+| `forge find <query>` | Substring search across names + descriptions |
+
+Spec-dir resolution order: `--spec-dir` flag > `$FORGE_SPEC_DIR` env var > auto-discover (walks upward looking for `.forge/`).
+
+Full CLI guide: [`docs/cli-guide.md`](docs/cli-guide.md).
+
+---
+
+## The ten skills
+
+| Skill | Role | Input | Output |
+|---|---|---|---|
+| **forge-discover** | Interviewer (product framing) | Vague idea | Project foundation: modules, L0 skeleton, L1 conventions, L5 posture |
+| **forge-decompose** | Structural extractor | One bounded module | Exhaustive atom stubs (four-pass extraction) |
+| **forge-atom** | Contract specifier | One atom stub | Complete L3 spec + L0 cascades + module completions |
+| **forge-compose** | Composition specifier | Completed atoms + project decisions | L4 flow/journey specs with explicit boundary/retry/compensation/idempotency decisions |
+| **forge-audit** | Challenger / reviewer | Completed specs | Severity-ranked findings with inline edits; seven audit passes |
+| **forge-armour** | Security challenger | Audited specs | Security hardening pass, trust-model capture, approved project/module/atom security edits |
+| **forge-implement** | Orchestrator | Audited spec corpus | Code + tests, dep-graph parallel, test-before-impl isolation |
+| **forge-validate** | Post-implementation validator | Implemented system + spec corpus | Validation report: static analysis, test-to-spec mapping, live interaction probes |
+| **forge-test-writer** | Subagent | One entity + level | Unit/integration/system tests with audit doc |
+| **forge-implementer** | Subagent | One entity | Implementation code, blind to tests |
+
+Skills activate via natural-language prompts (universal) or slash-commands (Claude Code only).
+
+Each skill has a framework doc (mental model) under `docs/skills/<skill>/framework.md` and a directive SKILL.md under `.agents/skills/<skill>/`.
+
+---
+
+## The spec system
+
+Six layers, each a source-of-truth YAML file set.
+
+| Layer | Purpose |
+|---|---|
+| **L0 Registry** | Vocabulary — types, errors, constants, external schemas, side-effect markers |
+| **L1 Conventions** | Project-wide defaults — retry policy, logging, security posture, verification floors |
+| **L2 Architecture** | Modules — ownership, tech stacks, persistence, permissions, policies |
+| **L3 Behavior** | Atoms (smallest spec unit) + artifacts (non-executing deps) |
+| **L4 Composition** | Flows (saga orchestrations) + journeys (user-facing paths) |
+| **L5 Operations** | Runtime — platform, deployment, rate limiting, event semantics, observability (SLA targets, metrics, alerts) |
+
+Schema reference: [`docs/framework-overview.md`](docs/framework-overview.md).
+Full schema templates: [`src/templates/`](src/templates/).
+
+---
+
+## Repository layout
+
+```
+forge/
+├── src/
+│   ├── cli/              Python CLI package (the forge command)
+│   ├── templates/        L0-L5 schema templates (symlinked into projects by forge init)
+│   └── example/          Working example spec corpus (used by tests)
+├── .agents/skills/       The 10 forge skills (installed into agent clients)
+│   ├── forge-discover/
+│   ├── forge-decompose/
+│   ├── forge-atom/
+│   ├── forge-compose/
+│   ├── forge-audit/
+│   ├── forge-armour/
+│   ├── forge-implement/
+│   ├── forge-validate/
+│   ├── forge-test-writer/
+│   └── forge-implementer/
+├── docs/
+│   ├── skills/           Framework docs for each skill (mental models)
+│   ├── cli-guide.md      Full CLI reference
+│   └── framework-overview.md
+├── scripts/
+│   └── install-skills.sh Global skill install + CLI symlink
+├── tests/                pytest suite — 54 tests
+├── pyproject.toml
+└── README.md
+```
+
+---
+
+## Development
+
+### Testing
+
+```bash
+.venv/bin/pytest -v
+```
+
+The `src/example/` directory is a complete working spec corpus (a fictional payments app) that doubles as the test fixture and a reference for what a finished project looks like.
+
+```bash
+export FORGE_SPEC_DIR="$(pwd)/src/example"
+forge list                              # see what's there
+forge context atm.pay.charge_card       # inspect a full atom bundle
+forge find charge                       # search across entities
+```
+
+### Adding a new skill
+
+1. Create `.agents/skills/<name>/SKILL.md` with [agentskills.io](https://agentskills.io) frontmatter (`name`, `description`).
+2. Add the skill to `SKILLS=()` in `scripts/install-skills.sh`.
+3. Add the skill to `SKILL_NAMES` in `src/cli/commands/init.py`.
+4. Add a framework doc under `docs/skills/<name>/framework.md` if the skill has a substantial mental model.
+5. `./scripts/install-skills.sh install` to wire up globally.
+6. In any existing projects: `forge update` to refresh their managed scaffolding and local skill links.
+
+### Uninstall
+
+```bash
+./scripts/install-skills.sh uninstall
+```
+
+Removes all global skill symlinks and the `forge` CLI binary. Does not touch project-local `.forge/` directories (those are owned by each project).
+
+---
+
+## Contributing
+
+Pull requests welcome. See [`CONTRIBUTING.md`](CONTRIBUTING.md) for:
+
+- Branching and commit conventions (Conventional Commits)
+- Local dev setup
+- PR requirements and CI expectations
+- Release process
+
+The repo uses standard open-source governance: no direct pushes to `main`, PRs require code-owner approval, CI must be green, history stays linear.
+
+Changes are tracked in [`CHANGELOG.md`](CHANGELOG.md) following [Keep a Changelog](https://keepachangelog.com).
+
+## Security
+
+Security issues: see [`SECURITY.md`](SECURITY.md). Do not open public issues for vulnerabilities.
+
+## License
+
+MIT — see [`LICENSE`](LICENSE).
+
+---
+
+<div align="center">
+
+<sub>Built for agent-driven development. Questions over prompts. Specs over intentions. Code follows.</sub>
+
+</div>

ai_forge_cli-0.1.2/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ai-forge-cli"
+version = "0.1.2"
+description = "Context walker for the Forge L0-L5 spec system"
+requires-python = ">=3.11"
+dependencies = ["pyyaml>=6.0"]
+
+[project.scripts]
+forge = "cli.forge:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["cli*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

ai_forge_cli-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ai_forge_cli-0.1.2/src/ai_forge_cli.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: ai-forge-cli
+Version: 0.1.2
+Summary: Context walker for the Forge L0-L5 spec system
+Requires-Python: >=3.11
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file

ai_forge_cli-0.1.2/src/ai_forge_cli.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+LICENSE
+README.md
+pyproject.toml
+src/ai_forge_cli.egg-info/PKG-INFO
+src/ai_forge_cli.egg-info/SOURCES.txt
+src/ai_forge_cli.egg-info/dependency_links.txt
+src/ai_forge_cli.egg-info/entry_points.txt
+src/ai_forge_cli.egg-info/requires.txt
+src/ai_forge_cli.egg-info/top_level.txt
+src/cli/__init__.py
+src/cli/__main__.py
+src/cli/bundle.py
+src/cli/common.py
+src/cli/forge.py
+src/cli/index.py
+src/cli/walker.py
+src/cli/commands/__init__.py
+src/cli/commands/base.py
+src/cli/commands/context.py
+src/cli/commands/find.py
+src/cli/commands/init.py
+src/cli/commands/inspect.py
+src/cli/commands/list_cmd.py
+src/cli/commands/update.py
+tests/test_cli.py
+tests/test_find.py
+tests/test_index.py
+tests/test_init.py
+tests/test_update.py
+tests/test_walker.py

ai_forge_cli-0.1.2/src/ai_forge_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ai_forge_cli-0.1.2/src/ai_forge_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+forge = cli.forge:main

ai_forge_cli-0.1.2/src/ai_forge_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+pyyaml>=6.0

ai_forge_cli-0.1.2/src/ai_forge_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+cli

ai_forge_cli-0.1.2/src/cli/__init__.py

@@ -0,0 +1,2 @@
+"""Forge CLI — context walker for the L0-L5 spec system."""
+__version__ = "0.1.0"

ai_forge_cli-0.1.2/src/cli/__main__.py

@@ -0,0 +1,4 @@
+from cli.forge import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ai_forge_cli-0.1.2/src/cli/bundle.py

@@ -0,0 +1,117 @@
+"""
+Bundle formatter — renders a walker output dict as YAML, JSON, or markdown.
+"""
+
+from __future__ import annotations
+
+import json
+from collections import OrderedDict
+from typing import Any
+
+import yaml
+
+
+# Human-readable headers for each bundle section.
+_SECTION_HEADERS: dict[str, str] = {
+    "target":                     "Target",
+    "l0_registry_slice":          "L0 — Registry (sliced)",
+    "l1_conventions":             "L1 — Conventions",
+    "l2_module":                  "L2 — Owner Module",
+    "l2_entry_points":            "L2 — Invoking Entry Points",
+    "policies_applied":           "L2 — Policies Applied",
+    "policies":                   "L2 — Policies",
+    "shared_module_interfaces":   "L2 — Whitelisted Module Interfaces",
+    "l3_atom":                    "L3 — Target Atom",
+    "l3_artifact":                "L3 — Target Artifact",
+    "owned_atoms":                "L3 — Owned Atoms",
+    "owned_artifacts":            "L3 — Owned Artifacts",
+    "called_atom_signatures":     "L3 — Called Atom Signatures",
+    "producer_atom_signature":    "L3 — Producer Atom Signature",
+    "source_artifacts":           "L3 — Upstream Source Artifacts",
+    "consumer_signatures":        "L3 — Consumer Signatures",
+    "training_artifact":          "L3 — Training Artifact",
+    "handler_atoms":              "L3 — Handler Atoms",
+    "step_atom_signatures":       "L3 — Step Atom Signatures",
+    "l4_journey":                 "L4 — Target Journey",
+    "l4_orchestration":           "L4 — Target Orchestration",
+    "invoked_orchestrations":     "L4 — Invoked Orchestrations",
+    "l4_callers":                 "L4 — Callers (atoms consumed here)",
+    "l5_operations":              "L5 — Operations",
+}
+
+
+# Ensure PyYAML emits OrderedDicts in insertion order.
+def _represent_ordered_dict(dumper, data):
+    return dumper.represent_mapping("tag:yaml.org,2002:map", data.items())
+
+
+yaml.add_representer(OrderedDict, _represent_ordered_dict)
+
+
+def render(bundle: OrderedDict[str, Any], fmt: str = "yaml") -> str:
+    if fmt == "json":
+        return json.dumps(bundle, indent=2, default=_json_default)
+    if fmt == "markdown":
+        return _render_markdown(bundle)
+    return _render_yaml(bundle)
+
+
+def _render_yaml(bundle: OrderedDict[str, Any]) -> str:
+    parts: list[str] = []
+    target = bundle.get("target") or {}
+    parts.append("# " + "=" * 66)
+    parts.append(f"# FORGE CONTEXT BUNDLE")
+    parts.append(f"# target: {target.get('id', '<unknown>')}")
+    parts.append(f"# kind:   {target.get('kind', '<unknown>')}")
+    if target.get("atom_kind"):
+        parts.append(f"# atom_kind: {target['atom_kind']}")
+    parts.append("# " + "=" * 66)
+    parts.append("")
+
+    for key, value in bundle.items():
+        if key == "target":
+            continue
+        if value is None or (isinstance(value, (dict, list)) and not value):
+            continue
+        header = _SECTION_HEADERS.get(key, key)
+        parts.append("# " + "-" * 66)
+        parts.append(f"# {header}")
+        parts.append("# " + "-" * 66)
+        parts.append(yaml.dump({key: value}, sort_keys=False, allow_unicode=True,
+                               default_flow_style=False, width=100).rstrip())
+        parts.append("")
+
+    return "\n".join(parts) + "\n"
+
+
+def _render_markdown(bundle: OrderedDict[str, Any]) -> str:
+    target = bundle.get("target") or {}
+    parts: list[str] = [
+        f"# Forge context: `{target.get('id', '<unknown>')}`",
+        "",
+        f"- **kind**: `{target.get('kind', '<unknown>')}`",
+    ]
+    if target.get("atom_kind"):
+        parts.append(f"- **atom_kind**: `{target['atom_kind']}`")
+    parts.append("")
+
+    for key, value in bundle.items():
+        if key == "target":
+            continue
+        if value is None or (isinstance(value, (dict, list)) and not value):
+            continue
+        header = _SECTION_HEADERS.get(key, key)
+        parts.append(f"## {header}")
+        parts.append("")
+        parts.append("```yaml")
+        parts.append(yaml.dump({key: value}, sort_keys=False, allow_unicode=True,
+                               default_flow_style=False, width=100).rstrip())
+        parts.append("```")
+        parts.append("")
+    return "\n".join(parts)
+
+
+def _json_default(o: Any) -> Any:
+    if isinstance(o, OrderedDict):
+        return dict(o)
+    raise TypeError(f"Unserializable: {type(o)}")

ai_forge_cli-0.1.2/src/cli/commands/__init__.py

@@ -0,0 +1,28 @@
+"""
+Command registry.
+
+To add a new command:
+  1. Create `cli/commands/<name>.py` exposing NAME, HELP, register, run
+     (see `base.py` for the contract, or copy any existing command as a
+     starting point).
+  2. Import it below and append to ALL_COMMANDS.
+
+That's it — `forge.py` auto-discovers every command in ALL_COMMANDS,
+builds its subparser, and wires dispatch via `args.handler`.
+"""
+
+from cli.commands import context as _context
+from cli.commands import find as _find
+from cli.commands import init as _init
+from cli.commands import inspect as _inspect
+from cli.commands import list_cmd as _list_cmd
+from cli.commands import update as _update
+
+ALL_COMMANDS = [
+    _init,
+    _update,
+    _context,
+    _list_cmd,
+    _inspect,
+    _find,
+]

ai_forge_cli-0.1.2/src/cli/commands/base.py

@@ -0,0 +1,26 @@
+"""
+Command module contract.
+
+Every module in `cli.commands` must expose:
+
+  NAME: str
+      The subcommand name. Used as `forge <NAME> ...` on the CLI.
+
+  HELP: str
+      One-line help text shown in `forge --help`.
+
+  def register(sub: argparse._SubParsersAction) -> None:
+      Add this command's subparser with all its arguments to the
+      provided _SubParsersAction. MUST call
+      `parser.set_defaults(handler=run)` on the created subparser so
+      dispatch works without any if/elif chain in forge.main.
+
+  def run(args: argparse.Namespace) -> int:
+      Execute the command. Return an exit code:
+        0 = success
+        1 = usage error (unknown id, missing spec dir, etc.)
+        2 = soft warning (e.g., bundle emitted but has unresolved refs)
+
+Commands should reuse helpers from `cli.common` rather than reimplementing
+spec-dir loading, id suggestion, or description formatting.
+"""

ai_forge_cli-0.1.2/src/cli/commands/context.py

@@ -0,0 +1,66 @@
+"""`forge context <id>` — build a full context bundle."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from cli import bundle as bundle_mod
+from cli import common
+from cli import index as index_mod
+from cli import walker
+
+NAME = "context"
+HELP = "Build a full implementation-ready context bundle for an id."
+DESCRIPTION = (
+    "Walks the spec dependency graph from <id> and emits everything "
+    "an agent needs to implement it: the target spec, referenced L0 "
+    "entries (sliced, not the whole registry), the owning module, "
+    "applicable policies, L1 conventions, L4 callers with derived "
+    "implications, and L5 operations."
+)
+
+
+def register(sub: argparse._SubParsersAction) -> None:
+    p = sub.add_parser(NAME, help=HELP, description=DESCRIPTION)
+    p.add_argument(
+        "id",
+        help="Target id. Must be an atom, module, journey, flow, or artifact.",
+    )
+    common.add_spec_dir_arg(p)
+    p.add_argument(
+        "--format", choices=["yaml", "json", "markdown"], default="yaml",
+        help=(
+            "Output format. yaml (default) is most token-efficient. "
+            "json is most parseable. markdown wraps each section in a "
+            "heading + code block for pasting into a chat."
+        ),
+    )
+    p.set_defaults(handler=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    idx, rc = common.load_index(args.spec_dir)
+    if rc != 0:
+        return rc
+
+    try:
+        index_mod.classify(idx, args.id)
+    except (KeyError, ValueError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        common.suggest_similar(idx, args.id)
+        return 1
+
+    bundle, unresolved = walker.walk(idx, args.id)
+    output = bundle_mod.render(bundle, fmt=args.format)
+    sys.stdout.write(output)
+
+    if unresolved:
+        seen: set[str] = set()
+        uniq = [u for u in unresolved if not (u in seen or seen.add(u))]
+        print(f"\n# Unresolved references ({len(uniq)}):", file=sys.stderr)
+        for u in uniq:
+            print(f"#   - {u}", file=sys.stderr)
+        return 2
+
+    return 0