archi-cli 0.1.0__tar.gz → 0.2.0__tar.gz

archi_cli-0.2.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.5
+Name: archi-cli
+Version: 0.2.0
+Summary: ar·cli·mate — de CLI in je ArchiMate: deterministisch native .archimate-modellen inspecteren, muteren, valideren en renderen
+Project-URL: Homepage, https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting
+Project-URL: Repository, https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting
+Project-URL: Issues, https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/issues
+Author: Bureau Architectuur Digitale Overheid
+License-Expression: EUPL-1.2
+License-File: LICENSE
+Keywords: archi,archimate,cli,enterprise-architecture,modeling
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.12
+Requires-Dist: lxml>=6.1.3
+Requires-Dist: typer>=0.26
+Description-Content-Type: text/markdown
+
+# AI-assisted architecting
+
+[![checks](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/actions/workflows/ci.yml/badge.svg)](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/actions/workflows/ci.yml)
+[![licentie: EUPL-1.2](https://img.shields.io/badge/licentie-EUPL--1.2-blue.svg)](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/archi-cli.svg)](https://pypi.org/project/archi-cli/)
+
+Een manier van architecteren waarbij een ArchiMate-model in het native
+Archi-formaat de bron van waarheid is, en je het met AI-assistentie bijhoudt in
+plaats van met de hand door de GUI te klikken. Deze repo levert de twee dingen
+die daarvoor nodig zijn:
+
+- **`archi-cli`**: een deterministische command line tool die een
+  `.archimate`-model inspecteert, muteert, valideert en rendert, en weigert een
+  kapot model op te slaan. Op PyPI, werkt op elk model.
+- **De skills** (`archi-model`, `archi-view`, `archi-slides`): de werkwijze
+  die een AI-sessie zoals Claude Code volgt om via de CLI aan het model te
+  werken. Te installeren als Claude Code plugin.
+
+Het model zelf hoort niet hier: dat woont in een eigen repo en gebruikt
+`archi-cli` als tool. Het ADO-model waarvoor dit ontstond is daar het
+voorbeeld.
+
+## De CLI
+
+```bash
+uv tool install archi-cli
+archi --help
+```
+
+Dat zet het commando `archi` op je `$PATH`. Het model wordt gevonden via
+`--model <pad>` (vóór het subcommando), via een `archi.toml` in de map
+(`[tool.archi] model = "..."`), of als het enige `.archimate`-bestand in de
+werkmap.
+
+```bash
+archi stats                                    # tellingen per type
+archi list --type Capability                   # elementen, gefilterd
+archi show "<elementnaam of id>"               # één element met relaties
+archi tree                                     # folderstructuur
+
+archi add-element --type Capability --name "..." --documentation "..."
+archi add-relation --type Aggregation --source "..." --target "..." --name "bevat"
+archi set-property <ref> "<key>=<waarde>"      # property zetten of bijwerken
+archi remove-property <ref> "<key>"            # property verwijderen
+archi set-documentation <ref> "..."            # Archi's documentatieveld
+archi add-element ... --subfolder "Gebied X"    # in een submap van de laag
+archi move <ref> --subfolder "Gebied X"        # naar een submap verplaatsen
+archi rename <ref> "Nieuwe naam"
+archi remove <ref> --cascade
+
+archi add-view --name "..." --layout cluster --type Capability --relation Aggregation
+archi slides --deck decks/<naam>.toml
+
+archi validate                                 # integriteitschecks
+archi normalize                                # canonieke serialisatie via Archi
+archi render                                   # views naar Mermaid en HTML
+```
+
+Voor `normalize` is de Archi-engine nodig; die haalt `archi` bij het eerste
+gebruik zelf op (of expliciet met `archi setup`), dus je hoeft Archi niet apart
+te installeren. `archi <commando> --help` toont de volledige set vlaggen;
+shell-completion zet je aan met `archi --install-completion`.
+
+Wat de tool bijzonder maakt:
+
+- **Muteren met een vangnet.** Elke wijziging valideert het model in het
+  geheugen; bij een fout weigert de CLI op te slaan. Ids zijn onveranderlijk.
+- **Canonieke serialisatie.** `normalize` laat de headless Archi-engine het
+  bestand herschrijven, zodat git-diffs klein blijven, of de wijziging nu van
+  de tool of van de Archi-GUI kwam.
+- **Renderen.** Elke view wordt een Mermaid-diagram (rendert op GitHub) en een
+  HTML-pagina die de layout uit het model volgt, plus een presentatie per
+  deckdefinitie.
+- **Doorklikken tussen views.** Met een links-bestand
+  (`[tool.archi] links = "…"` in `archi.toml`) worden elementen in de
+  HTML-views en slides klikbaar naar een andere view of een ander bestand,
+  bijvoorbeeld een SVG die een project met eigen scripts maakt. Zie
+  hieronder.
+
+### Doorklikken met een links-bestand
+
+Welk element waarheen doorklikt is een redactionele keuze, geen modelfeit;
+het staat daarom in een apart TOML-bestand (zie ADR 0010):
+
+```toml
+# archi.toml
+[tool.archi]
+links = "tools/links.toml"
+
+# tools/links.toml
+["overzicht-van-de-gebieden"]            # bestandsnaam van de bronplaat, zonder extensie
+"Gebied A" = "gebied-a-in-detail.html"   # elementnaam = pad, relatief aan de bronplaat
+"Gebied B" = "../eigen-svg/gebied-b.svg"
+```
+
+Een sectie hoort bij de HTML-view met die bestandsnaam (de slug van de
+viewnaam; bij views met botsende namen de naam mét id-suffix die `archi
+render` kiest), of bij een bestand dat een project zelf genereert: dezelfde
+sectievorm is dan bruikbaar voor eigen scripts, zodat één bestand over alle
+doorkliks gaat. In slides worden relatieve paden automatisch gecorrigeerd
+voor de submap. `archi validate` waarschuwt voor elementnamen die niet in de
+view (of het model) staan, `archi render` voor doelen die niet bestaan en
+voor secties die bij geen view of bestand horen.
+
+## De skills als Claude Code plugin
+
+Deze repo is tegelijk de plugin (`archi-tools`) en de marketplace die hem
+aanbiedt (`archi-marketplace`). Zo installeer je de skills bij je eigen model:
+
+```
+/plugin marketplace add BureauArchitectuurDigitaleOverheid/ai-assisted-architecting
+/plugin install archi-tools@archi-marketplace
+```
+
+De plugin brengt de drie skills mee; het `archi`-commando zelf komt van
+`uv tool install archi-cli`. Zie `adr/0007-claude-code-plugin.md`.
+
+## Ontwikkelen aan de tool
+
+```bash
+just setup       # venv, dependencies en de pre-commit hook
+just test        # de testsuite (draait op een fixture-model)
+just demo        # de CLI op het fixture-model
+just build       # distributies bouwen en de metadata controleren
+```
+
+De testsuite draait op `tests/fixtures/klein-model.archimate`, niet op een echt
+model. Wijzigingen lopen via een branch en een PR; CI draait de suite op Ubuntu
+en Windows. Publiceren naar PyPI gebeurt op een versie-tag, zie `CLAUDE.md` en
+`adr/0006-publiceren-op-pypi.md`.
+
+## Structuur
+
+```
+tools/archi_tool/       De archi-CLI (Python, lxml, Typer; beheerd met uv)
+tests/                  pytest-suite met een klein fixture-model
+.claude/skills/         De skills (archi-model, archi-view, archi-slides)
+.claude-plugin/         Plugin- en marketplace-manifest
+adr/                    Architectuurbeslissingen over de tool
+justfile                Vaste taken
+```
+
+## Licentie
+
+[EUPL-1.2](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/blob/main/LICENSE).

archi_cli-0.2.0/README.md

@@ -0,0 +1,145 @@
+# AI-assisted architecting
+
+[![checks](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/actions/workflows/ci.yml/badge.svg)](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/actions/workflows/ci.yml)
+[![licentie: EUPL-1.2](https://img.shields.io/badge/licentie-EUPL--1.2-blue.svg)](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/archi-cli.svg)](https://pypi.org/project/archi-cli/)
+
+Een manier van architecteren waarbij een ArchiMate-model in het native
+Archi-formaat de bron van waarheid is, en je het met AI-assistentie bijhoudt in
+plaats van met de hand door de GUI te klikken. Deze repo levert de twee dingen
+die daarvoor nodig zijn:
+
+- **`archi-cli`**: een deterministische command line tool die een
+  `.archimate`-model inspecteert, muteert, valideert en rendert, en weigert een
+  kapot model op te slaan. Op PyPI, werkt op elk model.
+- **De skills** (`archi-model`, `archi-view`, `archi-slides`): de werkwijze
+  die een AI-sessie zoals Claude Code volgt om via de CLI aan het model te
+  werken. Te installeren als Claude Code plugin.
+
+Het model zelf hoort niet hier: dat woont in een eigen repo en gebruikt
+`archi-cli` als tool. Het ADO-model waarvoor dit ontstond is daar het
+voorbeeld.
+
+## De CLI
+
+```bash
+uv tool install archi-cli
+archi --help
+```
+
+Dat zet het commando `archi` op je `$PATH`. Het model wordt gevonden via
+`--model <pad>` (vóór het subcommando), via een `archi.toml` in de map
+(`[tool.archi] model = "..."`), of als het enige `.archimate`-bestand in de
+werkmap.
+
+```bash
+archi stats                                    # tellingen per type
+archi list --type Capability                   # elementen, gefilterd
+archi show "<elementnaam of id>"               # één element met relaties
+archi tree                                     # folderstructuur
+
+archi add-element --type Capability --name "..." --documentation "..."
+archi add-relation --type Aggregation --source "..." --target "..." --name "bevat"
+archi set-property <ref> "<key>=<waarde>"      # property zetten of bijwerken
+archi remove-property <ref> "<key>"            # property verwijderen
+archi set-documentation <ref> "..."            # Archi's documentatieveld
+archi add-element ... --subfolder "Gebied X"    # in een submap van de laag
+archi move <ref> --subfolder "Gebied X"        # naar een submap verplaatsen
+archi rename <ref> "Nieuwe naam"
+archi remove <ref> --cascade
+
+archi add-view --name "..." --layout cluster --type Capability --relation Aggregation
+archi slides --deck decks/<naam>.toml
+
+archi validate                                 # integriteitschecks
+archi normalize                                # canonieke serialisatie via Archi
+archi render                                   # views naar Mermaid en HTML
+```
+
+Voor `normalize` is de Archi-engine nodig; die haalt `archi` bij het eerste
+gebruik zelf op (of expliciet met `archi setup`), dus je hoeft Archi niet apart
+te installeren. `archi <commando> --help` toont de volledige set vlaggen;
+shell-completion zet je aan met `archi --install-completion`.
+
+Wat de tool bijzonder maakt:
+
+- **Muteren met een vangnet.** Elke wijziging valideert het model in het
+  geheugen; bij een fout weigert de CLI op te slaan. Ids zijn onveranderlijk.
+- **Canonieke serialisatie.** `normalize` laat de headless Archi-engine het
+  bestand herschrijven, zodat git-diffs klein blijven, of de wijziging nu van
+  de tool of van de Archi-GUI kwam.
+- **Renderen.** Elke view wordt een Mermaid-diagram (rendert op GitHub) en een
+  HTML-pagina die de layout uit het model volgt, plus een presentatie per
+  deckdefinitie.
+- **Doorklikken tussen views.** Met een links-bestand
+  (`[tool.archi] links = "…"` in `archi.toml`) worden elementen in de
+  HTML-views en slides klikbaar naar een andere view of een ander bestand,
+  bijvoorbeeld een SVG die een project met eigen scripts maakt. Zie
+  hieronder.
+
+### Doorklikken met een links-bestand
+
+Welk element waarheen doorklikt is een redactionele keuze, geen modelfeit;
+het staat daarom in een apart TOML-bestand (zie ADR 0010):
+
+```toml
+# archi.toml
+[tool.archi]
+links = "tools/links.toml"
+
+# tools/links.toml
+["overzicht-van-de-gebieden"]            # bestandsnaam van de bronplaat, zonder extensie
+"Gebied A" = "gebied-a-in-detail.html"   # elementnaam = pad, relatief aan de bronplaat
+"Gebied B" = "../eigen-svg/gebied-b.svg"
+```
+
+Een sectie hoort bij de HTML-view met die bestandsnaam (de slug van de
+viewnaam; bij views met botsende namen de naam mét id-suffix die `archi
+render` kiest), of bij een bestand dat een project zelf genereert: dezelfde
+sectievorm is dan bruikbaar voor eigen scripts, zodat één bestand over alle
+doorkliks gaat. In slides worden relatieve paden automatisch gecorrigeerd
+voor de submap. `archi validate` waarschuwt voor elementnamen die niet in de
+view (of het model) staan, `archi render` voor doelen die niet bestaan en
+voor secties die bij geen view of bestand horen.
+
+## De skills als Claude Code plugin
+
+Deze repo is tegelijk de plugin (`archi-tools`) en de marketplace die hem
+aanbiedt (`archi-marketplace`). Zo installeer je de skills bij je eigen model:
+
+```
+/plugin marketplace add BureauArchitectuurDigitaleOverheid/ai-assisted-architecting
+/plugin install archi-tools@archi-marketplace
+```
+
+De plugin brengt de drie skills mee; het `archi`-commando zelf komt van
+`uv tool install archi-cli`. Zie `adr/0007-claude-code-plugin.md`.
+
+## Ontwikkelen aan de tool
+
+```bash
+just setup       # venv, dependencies en de pre-commit hook
+just test        # de testsuite (draait op een fixture-model)
+just demo        # de CLI op het fixture-model
+just build       # distributies bouwen en de metadata controleren
+```
+
+De testsuite draait op `tests/fixtures/klein-model.archimate`, niet op een echt
+model. Wijzigingen lopen via een branch en een PR; CI draait de suite op Ubuntu
+en Windows. Publiceren naar PyPI gebeurt op een versie-tag, zie `CLAUDE.md` en
+`adr/0006-publiceren-op-pypi.md`.
+
+## Structuur
+
+```
+tools/archi_tool/       De archi-CLI (Python, lxml, Typer; beheerd met uv)
+tests/                  pytest-suite met een klein fixture-model
+.claude/skills/         De skills (archi-model, archi-view, archi-slides)
+.claude-plugin/         Plugin- en marketplace-manifest
+adr/                    Architectuurbeslissingen over de tool
+justfile                Vaste taken
+```
+
+## Licentie
+
+[EUPL-1.2](https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting/blob/main/LICENSE).

{archi_cli-0.1.0 → archi_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "archi-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "ar·cli·mate — de CLI in je ArchiMate: deterministisch native .archimate-modellen inspecteren, muteren, valideren en renderen"
 readme = "README.md"
 license = "EUPL-1.2"
@@ -18,7 +18,8 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
-dependencies = ["lxml>=5.0", "typer>=0.26"]
+# lxml 6.1.3 stops resolving external parameter entities by default
+dependencies = ["lxml>=6.1.3", "typer>=0.26"]
 
 [project.urls]
 Homepage = "https://github.com/BureauArchitectuurDigitaleOverheid/ai-assisted-architecting"
@@ -38,12 +39,28 @@ build-backend = "hatchling.build"
 packages = ["tools/archi_tool"]
 
 [tool.hatch.build.targets.sdist]
+# only these paths; the leading ./ anchors README.md so views/README.md and
+# other nested READMEs don't get pulled in by a bare glob
 include = [
-    "tools/archi_tool",
-    "README.md",
-    "LICENSE",
-    "NOTICE",
+    "/tools/archi_tool",
+    "/README.md",
+    "/LICENSE",
+    "/NOTICE",
+    "/pyproject.toml",
 ]
 
 [dependency-groups]
 dev = ["pytest>=8", "pre-commit>=4"]
+
+[tool.ruff]
+target-version = "py312"
+
+[tool.ruff.lint]
+# Bugs and dead code first. Import sorting and the formatter follow in a
+# separate PR once the open feature branches have landed, so this one does
+# not cause merge conflicts in every file.
+select = ["E", "F", "W", "B"]
+ignore = [
+    "E501",  # line length is left to the formatter
+    "B008",  # Typer declares options as call defaults by design
+]

{archi_cli-0.1.0 → archi_cli-0.2.0}/tools/archi_tool/cli.py

@@ -16,10 +16,11 @@ from typing import Optional
 import typer
 from lxml import etree
 
-from .discovery import discover_conventions, discover_model
+from .discovery import discover_conventions, discover_links, discover_model
+from .links import check_link_files, load_links
 from .model import ArchiModel, ModelError, is_element, xsi_type
 from .normalize import normalize
-from .render import render_all, write_if_changed
+from .render import render_all, view_stems, write_if_changed
 from .render_html import render_all_html
 from .render_slides import load_deck, render_all_slides, render_deck_html
 from .validate import validate
@@ -42,7 +43,15 @@ def report_validation(model, model_path) -> bool:
     # validating a model from another project uses that project's conventions
     allowed_keys, _ = discover_conventions(
         model_path, start=Path(model_path).resolve().parent)
-    errors, warnings = validate(model, allowed_keys=allowed_keys)
+    # validation runs after every mutation: a broken links file must not
+    # block modelling (ADR 0010), so here it degrades to a warning; render
+    # and slides, which actually use the links, still fail on it
+    try:
+        links = load_links(discover_links(model_path))
+    except ModelError as exc:
+        print(f"WAARSCHUWING: links-bestand genegeerd: {exc}")
+        links = {}
+    errors, warnings = validate(model, allowed_keys=allowed_keys, links=links)
     for warning in warnings:
         print(f"WAARSCHUWING: {warning}")
     for error in errors:
@@ -144,7 +153,9 @@ def cmd_validate(model, args):
 def cmd_add_element(model, args):
     el = model.add_element(args.type, args.name, folder_type=args.folder,
                            properties=parse_properties(args.property),
-                           documentation=args.documentation)
+                           documentation=args.documentation,
+                           subfolder=args.subfolder,
+                           create_subfolder=args.create_subfolder)
     status = save_validated(model, args)
     if status == 0:
         print(f"Toegevoegd: {describe(model, el)}")
@@ -153,7 +164,8 @@ def cmd_add_element(model, args):
 
 def cmd_add_relation(model, args):
     rel = model.add_relation(args.type, args.source, args.target,
-                             name=args.name)
+                             name=args.name, subfolder=args.subfolder,
+                             create_subfolder=args.create_subfolder)
     status = save_validated(model, args)
     if status == 0:
         print(f"Toegevoegd: {rel.get('id')} [{xsi_type(rel)}] "
@@ -172,6 +184,23 @@ def cmd_set_property(model, args):
     return status
 
 
+def cmd_move(model, args):
+    target = model.move(args.ref, args.subfolder,
+                        create_subfolder=args.create_subfolder)
+    status = save_validated(model, args)
+    if status == 0:
+        print(f"Verplaatst: '{args.ref}' naar folder '{target.get('name')}'")
+    return status
+
+
+def cmd_remove_property(model, args):
+    model.remove_property(args.ref, args.key)
+    status = save_validated(model, args)
+    if status == 0:
+        print(f"Property verwijderd van '{args.ref}': {args.key}")
+    return status
+
+
 def cmd_rename(model, args):
     model.rename(args.ref, args.name)
     status = save_validated(model, args)
@@ -244,10 +273,12 @@ def cmd_setup(model, args):
 
 
 def cmd_render(model, args):
+    links = load_links(discover_links(args.model))
     written, removed = render_all(model, args.out)
-    html_written, html_removed = render_all_html(model, Path(args.out) / "html")
+    html_dir = Path(args.out) / "html"
+    html_written, html_removed = render_all_html(model, html_dir, links=links)
     deck_written, deck_removed = render_all_slides(
-        model, Path(args.decks), Path(args.out) / "html" / "slides")
+        model, Path(args.decks), html_dir / "slides", links=links)
     for path in written + html_written + deck_written:
         print(f"Geschreven: {path}")
     for path in removed + html_removed:
@@ -257,22 +288,27 @@ def cmd_render(model, args):
     if not (written or removed or html_written or html_removed
             or deck_written or deck_removed):
         print("Views zijn al actueel.")
+    view_files = set(view_stems(model).values())
+    for warning in check_link_files(links, args.out, html_dir, view_files):
+        print(f"WAARSCHUWING: {warning}")
     return 0
 
 
 def cmd_slides(model, args):
+    links = load_links(discover_links(args.model))
     if args.deck:
         written = []
         for deck_path in args.deck:
             deck = load_deck(Path(deck_path), model)
             path = Path(args.out) / f"{deck['slug']}.html"
             path.parent.mkdir(parents=True, exist_ok=True)
-            if write_if_changed(path, render_deck_html(model, deck)):
+            if write_if_changed(path, render_deck_html(model, deck,
+                                                       links=links)):
                 written.append(path)
         removed = []
     else:
         written, removed = render_all_slides(
-            model, Path(args.decks), Path(args.out))
+            model, Path(args.decks), Path(args.out), links=links)
     for path in written:
         print(f"Geschreven: {path}")
     for path in removed:
@@ -330,10 +366,10 @@ def _run(command_fn, *, load_model=True, need_model=True, **fields) -> None:
         status = command_fn(model, args)
     except ModelError as exc:
         typer.echo(f"FOUT: {exc}", err=True)
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
     except (etree.XMLSyntaxError, OSError) as exc:
         typer.echo(f"FOUT: kan {args.model} niet lezen: {exc}", err=True)
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
     raise typer.Exit(status)
 
 
@@ -395,9 +431,15 @@ def add_element(
     property: Optional[list[str]] = typer.Option(
         None, "--property", help="key=value (herhaalbaar)"),
     documentation: Optional[str] = typer.Option(None),
+    subfolder: Optional[str] = typer.Option(
+        None, help="submap binnen de laagfolder, geneste mappen met '/'"),
+    create_subfolder: bool = typer.Option(
+        False, "--create-subfolder",
+        help="ontbrekende submap aanmaken (anders: fout)"),
 ):
     _run(cmd_add_element, type=type, name=name, folder=folder,
-         property=property, documentation=documentation)
+         property=property, documentation=documentation,
+         subfolder=subfolder, create_subfolder=create_subfolder)
 
 
 @app.command("add-relation", help="relatie toevoegen")
@@ -407,9 +449,29 @@ def add_relation(
     source: str = typer.Option(..., help="id of unieke naam"),
     target: str = typer.Option(..., help="id of unieke naam"),
     name: Optional[str] = typer.Option(None, help="NL-label op de relatie"),
+    subfolder: Optional[str] = typer.Option(
+        None, help="submap binnen Relations, geneste mappen met '/'"),
+    create_subfolder: bool = typer.Option(
+        False, "--create-subfolder",
+        help="ontbrekende submap aanmaken (anders: fout)"),
 ):
     _run(cmd_add_relation, type=type, source=source,
-         target=target, name=name)
+         target=target, name=name, subfolder=subfolder,
+         create_subfolder=create_subfolder)
+
+
+@app.command(help="element, relatie of view naar een submap verplaatsen")
+def move(
+    ref: str = typer.Argument(help="id of (unieke) naam"),
+    subfolder: str = typer.Option(
+        ..., help="submap binnen de huidige laagfolder, geneste mappen met "
+                  "'/'; leeg ('') = terug naar de laagfolder zelf"),
+    create_subfolder: bool = typer.Option(
+        False, "--create-subfolder",
+        help="ontbrekende submap aanmaken (anders: fout)"),
+):
+    _run(cmd_move, ref=ref, subfolder=subfolder,
+         create_subfolder=create_subfolder)
 
 
 @app.command("set-property", help="property zetten of bijwerken")
@@ -420,6 +482,14 @@ def set_property(
     _run(cmd_set_property, ref=ref, pair=pair)
 
 
+@app.command("remove-property", help="property verwijderen")
+def remove_property(
+    ref: str = typer.Argument(help="id of (unieke) naam"),
+    key: str = typer.Argument(help="property-key"),
+):
+    _run(cmd_remove_property, ref=ref, key=key)
+
+
 @app.command(help="element of relatie hernoemen")
 def rename(
     ref: str = typer.Argument(help="id of (unieke) naam"),

{archi_cli-0.1.0 → archi_cli-0.2.0}/tools/archi_tool/discovery.py

@@ -1,9 +1,9 @@
-"""Locate the model file and the conventions list without assuming this repo.
+"""Locate the model file and the conventions list without assuming a layout.
 
-The CLI used to hardcode ``models/ado.archimate`` and find the conventions at
-``<model>/../../docs/conventies.md``. Both assumptions are specific to this
-repository. Discovery makes ``archi`` work on any model, in any layout, while
-keeping the ADO defaults working through an ``archi.toml`` in the repo root.
+An earlier version hardcoded a fixed model path and found the conventions doc
+at a fixed location. Discovery makes ``archi`` work on any model, in any
+layout: a project points at its model and conventions through an ``archi.toml``
+(or ``pyproject.toml``), or the tool falls back to sensible defaults.
 
 Resolution order for the model:
   1. an explicit ``--model`` path (handled by the caller)
@@ -27,19 +27,14 @@ from .model import ModelError
 CONFIG_NAMES = ("archi.toml", "pyproject.toml")
 CONVENTION_NEIGHBOURS = ("conventies.md", "conventions.md")
 
-# Keys that ship with the tool. A project can override this by pointing at its
-# own conventions doc; without one, these keep the property-key check useful.
-# Mirrors docs/conventies.md §3 so behaviour is identical for this repo when no
-# doc is found (it normally is, via archi.toml).
+# Generic keys that ship with the tool as a fallback allowlist. A project
+# overrides this by pointing at its own conventions doc (with a Property-keys
+# section); without one, these keep the property-key check useful instead of
+# silently disabling it. Descriptions belong in Archi's documentation field,
+# not in a property, so "Omschrijving"/"Toelichting" are deliberately absent
+# (ADR 0009).
 DEFAULT_PROPERTY_KEYS = {
-    "Omschrijving",
-    "Toelichting",
     "Bron",
-    "Capability-niveau",
-    "Niveau (herkomst)",
-    "Driver-categorie",
-    "constraint-type",
-    "Artefact-type",
 }
 
 
@@ -101,6 +96,24 @@ def discover_model(explicit=None, start=None):
         "--model <pad> of leg het vast in archi.toml.")
 
 
+def discover_links(model_path, start=None):
+    """Return the path of the links file, or None when none is configured.
+
+    Only ``[tool.archi] links`` in a config file counts (there is no
+    filesystem fallback: click-through is opt-in). A configured path that
+    does not exist is a config error.
+    """
+    start = Path(start or Path(model_path).resolve().parent)
+    table, config_path = _read_archi_config(start)
+    if "links" not in table:
+        return None
+    path = (config_path.parent / table["links"]).resolve()
+    if not path.exists():
+        raise ModelError(
+            f"Linkspad uit {config_path.name} bestaat niet: {path}")
+    return path
+
+
 def discover_conventions(model_path, start=None):
     """Return (allowed_property_keys, source_label).
 

{archi_cli-0.1.0 → archi_cli-0.2.0}/tools/archi_tool/engine.py

@@ -153,7 +153,7 @@ def _safe_extract_tar(tar, target):
     try:
         tar.extractall(target, filter="data")
     except tarfile.FilterError as exc:
-        raise ModelError(f"Onveilig pad in archief: {exc}")
+        raise ModelError(f"Onveilig pad in archief: {exc}") from exc
 
 
 def _safe_extract_zip(zf, target):
@@ -259,7 +259,7 @@ def download_engine(*, quiet=False) -> Path:
         os.replace(staging, version_dir)
     except OSError as exc:
         raise ModelError(
-            f"Kon de Archi-engine niet ophalen van {url}: {exc}")
+            f"Kon de Archi-engine niet ophalen van {url}: {exc}") from exc
     finally:
         shutil.rmtree(staging, ignore_errors=True)