deriva-cli 0.8.2__tar.gz → 0.8.3__tar.gz

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deriva-cli
-Version: 0.8.2
+Version: 0.8.3
 Summary: Deriva is a research project aimed at enabling digital architects by automating the derivation of enterprise architecture models. Deriva uses dual knowledge graphs, heuristics and LLM's.
 Keywords: archimate,enterprise-architecture,code-analysis,llm,grafeo,fastapi
 Author: S. T. Grond

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/archimate/manager.py

@@ -577,6 +577,35 @@ class ArchimateManager:
             key=lambda e: str(e["identifier"]),
         )
 
+    def update_element_properties(self, updates: dict[str, dict[str, Any]]) -> int:
+        """Merge keys into the properties of elements (identifier -> keys), leaving their other keys; returns how many changed."""
+        if self.db is None:
+            raise RuntimeError("Not connected to grafeo. Call connect() first.")
+        changed = 0
+        for identifier, keys in sorted(updates.items()):
+            rows = self.db.execute(f"MATCH (e:`{self.namespace}` {{identifier: $identifier}}) RETURN e.properties AS properties", {"identifier": identifier})
+            if not rows:
+                continue
+            merged = {**(rows[0].get("properties") or {}), **keys}
+            self.db.execute_write(f"MATCH (e:`{self.namespace}` {{identifier: $identifier}}) SET e.properties = $properties", {"identifier": identifier, "properties": merged})
+            changed += 1
+        return changed
+
+    def update_relationship_properties(self, updates: dict[str, dict[str, Any]]) -> int:
+        """Merge keys into the properties of relationships (identifier -> keys), in place; returns how many changed."""
+        if self.db is None:
+            raise RuntimeError("Not connected to grafeo. Call connect() first.")
+        changed = 0
+        for identifier, keys in sorted(updates.items()):
+            match = f"MATCH (:`{self.namespace}`)-[r {{identifier: $identifier}}]->(:`{self.namespace}`)"
+            rows = self.db.execute(f"{match} RETURN r.properties AS properties", {"identifier": identifier})
+            if not rows:
+                continue
+            merged = {**(rows[0].get("properties") or {}), **keys}
+            self.db.execute_write(f"{match} SET r.properties = $properties", {"identifier": identifier, "properties": merged})
+            changed += 1
+        return changed
+
     def delete_relationship(self, identifier: str) -> bool:
         """Delete a relationship by identifier.
 

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/archimate/views.py

@@ -1,7 +1,8 @@
 """Generated views (pure): ArchiMate viewpoints per level with a deterministic band layout.
 
-Each viewpoint (ArchiMate 3.2 Specification, chapter 13) shows the architect elements of its types; a detail
-variant adds the detail elements (property ``level`` = detail) nested under those types. The layout puts the
+Each viewpoint (ArchiMate 3.2 Specification, chapter 13) shows the elements of its types on its level (enterprise or
+solution, from the element's ``levels``) and the relationships on that level; a cross-level link is in no view. A
+detail variant shows the solution elements of its types with their detail elements (property ``level`` = detail). The layout puts the
 layers in horizontal bands (business, application, technology) and the elements of a band in a grid, ordered by
 type and name, each detail element right after its parent, so the same model gives the same view in every run.
 """
@@ -12,23 +13,32 @@ from dataclasses import dataclass, field
 
 from .models import Element, Relationship, layer_of
 
-# (view name, viewpoint, element types, with detail elements)
-VIEWPOINTS: tuple[tuple[str, str, frozenset[str] | None, bool], ...] = (
-    ("Layered", "Layered", None, False),
-    ("Application Cooperation", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface", "ApplicationService"}), False),
-    ("Information Structure", "Information Structure", frozenset({"BusinessObject", "DataObject"}), False),
-    ("Information Structure (detail)", "Information Structure", frozenset({"BusinessObject", "DataObject"}), True),
-    ("Implementation and Deployment", "Implementation and Deployment", frozenset({"ApplicationComponent", "Node", "Device", "SystemSoftware", "TechnologyService"}), False),
+ENTERPRISE, SOLUTION, DETAIL = "enterprise", "solution", "detail"
+DEPLOYMENT = frozenset({"ApplicationComponent", "Node", "Device", "SystemSoftware", "TechnologyService"})
+# (view name, viewpoint, element types, level), in export order
+VIEWPOINTS: tuple[tuple[str, str, frozenset[str] | None, str], ...] = (
+    ("Layered (enterprise)", "Layered", None, ENTERPRISE),
+    ("Application Cooperation (enterprise)", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface", "ApplicationService"}), ENTERPRISE),
+    ("Information Structure (enterprise)", "Information Structure", frozenset({"BusinessObject", "DataObject"}), ENTERPRISE),
+    ("Implementation and Deployment (enterprise)", "Implementation and Deployment", DEPLOYMENT, ENTERPRISE),
     (
-        "Implementation and Deployment (detail)",
-        "Implementation and Deployment",
-        frozenset({"ApplicationComponent", "Node", "Device", "SystemSoftware", "TechnologyService", "Artifact"}),
-        True,
+        "Business (enterprise)",
+        "Business Process Cooperation",
+        frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent", "ApplicationService"}),
+        ENTERPRISE,
     ),
-    ("Business", "Business Process Cooperation", frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent", "ApplicationService"}), False),
+    ("Application Structure (solution)", "Application Structure", frozenset({"ApplicationComponent"}), SOLUTION),
+    ("Application Cooperation (solution)", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface"}), SOLUTION),
+    ("Information Structure (solution)", "Information Structure", frozenset({"DataObject"}), SOLUTION),
+    ("Implementation and Deployment (solution)", "Implementation and Deployment", DEPLOYMENT, SOLUTION),
+    ("Information Structure (detail)", "Information Structure", frozenset({"DataObject"}), DETAIL),
+    ("Implementation and Deployment (detail)", "Implementation and Deployment", DEPLOYMENT | {"Artifact"}, DETAIL),
+    # The interfaces with their members (endpoints, pages, jobs); components are left out, their members are above
+    ("Application Interfaces (detail)", "Application Cooperation", frozenset({"ApplicationInterface"}), DETAIL),
 )
+
 # A view needs an element of its anchor types (the Business view: a business element, not application services alone)
-ANCHORS = {"Business": frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent"})}
+ANCHORS = {"Business (enterprise)": frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent"})}
 BANDS = ("Business", "Application", "Technology", "Other")
 TYPE_ORDER = (
     "BusinessActor", "BusinessFunction", "BusinessProcess", "BusinessEvent", "BusinessObject",
@@ -61,7 +71,7 @@ class View:
     identifier: str
     name: str
     viewpoint: str
-    level: str = "architect"  # detail: the view shows the detail elements too
+    level: str = ENTERPRISE  # enterprise, solution or detail (a detail view shows the detail elements too)
     nodes: list[ViewNode] = field(default_factory=list)
     connections: list[ViewConnection] = field(default_factory=list)
 
@@ -70,6 +80,23 @@ def _level(e: Element) -> str:
     return str((e.properties or {}).get("level") or "architect")
 
 
+def _levels(properties: dict | None) -> frozenset[str]:
+    """The levels of an element or relationship: ``level`` detail, else ``levels`` (empty: a cross-level link), else the
+    enterprise level (a model from before the levels)."""
+    properties = properties or {}
+    if properties.get("level") == DETAIL:
+        return frozenset({DETAIL})
+    levels = properties.get("levels")
+    if isinstance(levels, list):
+        return frozenset(str(v) for v in levels)
+    return frozenset() if properties.get("cross_level") else frozenset({ENTERPRISE})
+
+
+def _on(level: str, levels: frozenset[str]) -> bool:
+    """Whether something on ``levels`` belongs in a view of ``level`` (a detail view: the solution level and the detail)."""
+    return bool(levels & ({SOLUTION, DETAIL} if level == DETAIL else {level}))
+
+
 def _order(e: Element) -> tuple[int, str, str]:
     return (TYPE_ORDER.index(e.element_type) if e.element_type in TYPE_ORDER else len(TYPE_ORDER), e.name.casefold(), e.identifier)
 
@@ -102,19 +129,25 @@ def _layout(view: View, shown: list[Element]) -> None:
         y += BAND_GAP
 
 
-def build_views(elements: list[Element], relationships: list[Relationship]) -> list[View]:
-    """The views of the model, one per viewpoint that has elements, in VIEWPOINTS order."""
+def build_views(elements: list[Element], relationships: list[Relationship], relationship_levels: dict[str, frozenset[str]] | None = None) -> list[View]:
+    """The views of the model, one per viewpoint that has elements on its level, in VIEWPOINTS order.
+
+    Args:
+        relationship_levels: Relationship id -> its levels, where the relationship's own properties do not say (the
+            export's detail relationships); else from the properties
+    """
     views: list[View] = []
-    for number, (name, viewpoint, types, with_detail) in enumerate(VIEWPOINTS, 1):
-        shown = [e for e in elements if (types is None or e.element_type in types) and (with_detail or _level(e) != "detail")]
+    for number, (name, viewpoint, types, level) in enumerate(VIEWPOINTS, 1):
+        shown = [e for e in elements if (types is None or e.element_type in types) and _on(level, _levels(e.properties))]
         anchors = ANCHORS.get(name)
-        if not shown or (anchors and not any(e.element_type in anchors for e in shown)) or (with_detail and not any(_level(e) == "detail" for e in shown)):
+        if not shown or (anchors and not any(e.element_type in anchors for e in shown)) or (level == DETAIL and not any(_level(e) == DETAIL for e in shown)):
             continue
-        view = View(identifier=f"view-{number}", name=name, viewpoint=viewpoint, level="detail" if with_detail else "architect")
+        view = View(identifier=f"view-{number}", name=name, viewpoint=viewpoint, level=level)
         _layout(view, shown)
         node_of = {n.element: n.identifier for n in view.nodes}
         for r in sorted(relationships, key=lambda r: r.identifier):
-            if r.source in node_of and r.target in node_of:
+            on = (relationship_levels or {}).get(r.identifier) or _levels(r.properties)
+            if r.source in node_of and r.target in node_of and _on(level, on):
                 connection = ViewConnection(identifier=f"{view.identifier}-c-{r.identifier}", relationship=r.identifier, source=node_of[r.source], target=node_of[r.target])
                 view.connections.append(connection)
         views.append(view)

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/archimate/xml_export.py

@@ -51,6 +51,7 @@ class ArchiMateXMLExporter:
         model_id: str = "model-001",
         properties: Mapping[str, Mapping[str, str]] | None = None,
         views: Sequence[View] | None = None,
+        relationship_properties: Mapping[str, Mapping[str, str]] | None = None,
     ) -> None:
         """
         Export ArchiMate model to XML file.
@@ -63,6 +64,7 @@ class ArchiMateXMLExporter:
             model_id: Unique identifier for the model
             properties: Exported properties per element id (e.g. ``level``), declared as propertyDefinitions
             views: Diagrams to export (see ``views.build_views``)
+            relationship_properties: Exported properties per relationship id, declared with the element ones
         """
         # Create root model element
         root = etree.Element(
@@ -83,7 +85,8 @@ class ArchiMateXMLExporter:
         self._add_metadata(root)
 
         properties = properties or {}
-        keys = sorted({key for values in properties.values() for key, value in values.items() if value})
+        relationship_properties = relationship_properties or {}
+        keys = sorted({key for values in [*properties.values(), *relationship_properties.values()] for key, value in values.items() if value})
         definition_of = {key: f"propid-{key}" for key in keys}
 
         # Add elements section
@@ -96,7 +99,7 @@ class ArchiMateXMLExporter:
         if relationships:
             rels_section = etree.SubElement(root, "relationships")
             for relationship in relationships:
-                self._add_relationship(rels_section, relationship)
+                self._add_relationship(rels_section, relationship, relationship_properties.get(relationship.identifier, {}), definition_of)
 
         # The exchange format's order: elements, relationships, organizations, propertyDefinitions, views
         if keys:
@@ -105,7 +108,7 @@ class ArchiMateXMLExporter:
                 definition = etree.SubElement(definitions, "propertyDefinition", attrib={"identifier": definition_of[key], "type": "string"})
                 etree.SubElement(definition, "name").text = key
         if views:
-            self._add_views(root, views)
+            self._add_views(root, views, definition_of.get("level"))
 
         # Write to file
         tree = etree.ElementTree(root)
@@ -190,8 +193,9 @@ class ArchiMateXMLExporter:
                 value_elem.set(f"{{{self.XML_NS}}}lang", "en")
                 value_elem.text = value
 
-    def _add_views(self, root: etree.Element, views: Sequence[View]) -> None:
-        """Add the diagrams: element nodes with their bounds, relationship connections between them."""
+    def _add_views(self, root: etree.Element, views: Sequence[View], level_definition: str | None = None) -> None:
+        """Add the diagrams: element nodes with their bounds, relationship connections between them, and each view's
+        level as a property where the model declares one."""
         diagrams = etree.SubElement(etree.SubElement(root, "views"), "diagrams")
         for view in views:
             diagram = etree.SubElement(
@@ -202,6 +206,11 @@ class ArchiMateXMLExporter:
             name_elem = etree.SubElement(diagram, "name")
             name_elem.set(f"{{{self.XML_NS}}}lang", "en")
             name_elem.text = view.name
+            if level_definition:
+                prop = etree.SubElement(etree.SubElement(diagram, "properties"), "property", attrib={"propertyDefinitionRef": level_definition})
+                value_elem = etree.SubElement(prop, "value")
+                value_elem.set(f"{{{self.XML_NS}}}lang", "en")
+                value_elem.text = view.level
             for node in view.nodes:
                 etree.SubElement(
                     diagram,
@@ -229,13 +238,21 @@ class ArchiMateXMLExporter:
                     },
                 )
 
-    def _add_relationship(self, parent: etree.Element, relationship: Relationship) -> None:
+    def _add_relationship(
+        self,
+        parent: etree.Element,
+        relationship: Relationship,
+        properties: Mapping[str, str] | None = None,
+        definition_of: Mapping[str, str] | None = None,
+    ) -> None:
         """
         Add a relationship to the XML tree.
 
         Args:
             parent: Parent XML element
             relationship: ArchiMate relationship to add
+            properties: The relationship's exported properties (key -> value)
+            definition_of: propertyDefinition identifier per key
         """
         rel = etree.SubElement(
             parent,
@@ -258,8 +275,15 @@ class ArchiMateXMLExporter:
             doc_elem = etree.SubElement(rel, "documentation")
             doc_elem.text = relationship.documentation
 
-        # Note: Properties are not exported as they require propertyDefinitions
-        # at the model level per ArchiMate Exchange Format XSD.
+        # Only the properties passed in are exported (each needs a model-level propertyDefinition), after name and documentation
+        shown = sorted((key, value) for key, value in (properties or {}).items() if value and key in (definition_of or {}))
+        if shown and definition_of:
+            props = etree.SubElement(rel, "properties")
+            for key, value in shown:
+                prop = etree.SubElement(props, "property", attrib={"propertyDefinitionRef": definition_of[key]})
+                value_elem = etree.SubElement(prop, "value")
+                value_elem.set(f"{{{self.XML_NS}}}lang", "en")
+                value_elem.text = str(value)
 
     def export_to_string(
         self,

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/database/__init__.py

@@ -30,6 +30,7 @@ from .db_tool import export_all as export_database
 from .db_tool import import_all as import_database
 from .manager import (
     DB_PATH,
+    ConfigDatabaseBusy,
     ensure_database,
     get_connection,
     init_database,
@@ -43,6 +44,7 @@ FUNCTION_MODELS_DIR = DATA_DIR / "function_models"
 
 __all__ = [
     "FUNCTION_MODELS_DIR",
+    "ConfigDatabaseBusy",
     "ensure_database",
     "get_connection",
     "init_database",

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/database/manager.py

@@ -28,6 +28,14 @@ SCRIPTS_DIR = Path(__file__).parent / "scripts"
 DATA_DIR = Path(__file__).parent / "data"
 
 
+# How DuckDB reports a database file another process holds (Windows; Linux and macOS)
+_LOCK_MESSAGES = ("being used by another process", "Could not set lock", "Conflicting lock")
+
+
+class ConfigDatabaseBusy(RuntimeError):
+    """The config database is open in another process (DuckDB allows one writer)."""
+
+
 def get_connection(read_only: bool = False) -> duckdb.DuckDBPyConnection:
     """Get a connection to the database.
 
@@ -37,11 +45,21 @@ def get_connection(read_only: bool = False) -> duckdb.DuckDBPyConnection:
 
     Returns:
         DuckDB connection
+
+    Raises:
+        ConfigDatabaseBusy: Another process (the studio, another CLI run) holds the database
     """
     # A fresh install has no database yet: create it from the schema and the shipped seed data
     if not DB_PATH.exists():
         ensure_database(DB_PATH)
-    return duckdb.connect(str(DB_PATH), read_only=read_only)
+    try:
+        return duckdb.connect(str(DB_PATH), read_only=read_only)
+    except duckdb.IOException as e:
+        if any(message in str(e) for message in _LOCK_MESSAGES):
+            raise ConfigDatabaseBusy(
+                f"The config database {DB_PATH} is open in another Deriva process (the studio or another deriva-cli run). Close it, or wait for it to finish, then try again."
+            ) from e
+        raise
 
 
 def run_sql_file(filepath: Path, conn: duckdb.DuckDBPyConnection | None = None) -> int:

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/graph/manager.py

@@ -36,6 +36,7 @@ from deriva.common.ocel import create_edge_id
 from deriva.common.settings import GraphSettings
 
 from .models import (
+    BuildModuleNode,
     BusinessConceptNode,
     DataDomainNode,
     DataEntityNode,
@@ -72,6 +73,7 @@ GraphNode = (
     | ServiceNode
     | ExternalDependencyNode
     | DeployableUnitNode
+    | BuildModuleNode
     | DataEntityNode
     | DataDomainNode
     | EnvironmentNode

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/graph/models.py

@@ -506,6 +506,45 @@ class ExternalDependencyNode:
         }
 
 
+@dataclass
+class BuildModuleNode:
+    """A build module (a folder with a build manifest and code of its own) or a parent system (an aggregator manifest
+    that lists modules). Its own files hang below it by ``INCLUDES``, nested modules by ``NESTS``; a deployable unit
+    ``BUILDS`` the modules in its folder."""
+
+    name: str
+    path: str
+    manifest: str
+    repository_name: str
+    is_module: bool = False
+    is_system: bool = False
+    members: list[str] = field(default_factory=list)  # For a system: the module paths its manifest lists
+    same_as: str | None = None  # The unit whose folder it is (one unit there, no module inside): one element with it
+    excluded: str | None = None  # Why it is no application component (infrastructure-as-code, test-only)
+
+    def generate_id(self) -> str:
+        """Generate a unique ID for this node."""
+        return f"BuildModule_{self.path}"
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for graph storage."""
+        return {
+            "name": self.name,
+            "path": self.path,
+            "manifest": self.manifest,
+            "isModule": self.is_module,
+            "isSystem": self.is_system,
+            "members": list(self.members),
+            "sameAs": self.same_as,
+            "excluded": self.excluded,
+            # Its structural name as the one candidate of the closed-set naming (no naming call)
+            "nameCandidates": [self.name],
+            # Module ids carry no prefix the graph manager reads the repository from
+            "repository_name": self.repository_name,
+            "type": "BuildModule",
+        }
+
+
 @dataclass
 class DeployableUnitNode:
     """A deployable unit: what runs on its own (a container, a declared entry point, a mainframe application).

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/adapters/repository/manager.py

@@ -37,6 +37,7 @@ from typing import Any
 import yaml
 
 from deriva.common.paths import resolve
+from deriva.common.settings import RepositorySettings
 
 from .models import (
     CloneError,
@@ -494,22 +495,6 @@ def _extract_file_structure(repo_path: Path) -> FileNode:
 # =============================================================================
 
 
-def _load_config() -> dict:
-    """Load configuration from config.yaml file."""
-    config_path = Path(__file__).parent / "config.yaml"
-    default_config = {"workspace_dir": "workspace/repositories"}
-
-    if not config_path.exists():
-        return default_config
-
-    try:
-        with open(config_path) as f:
-            config = yaml.safe_load(f) or {}
-            return {**default_config, **config}
-    except Exception:
-        return default_config
-
-
 # =============================================================================
 # Repository Manager
 # =============================================================================
@@ -535,12 +520,12 @@ class RepoManager:
         """Initialize the Repository Manager.
 
         Args:
-            workspace_dir: Directory where repositories will be stored.
-                          Defaults to workspace/repositories in the Deriva home folder.
+            workspace_dir: Directory where repositories will be stored. Defaults to the
+                          REPOSITORY_WORKSPACE_DIR setting (workspace/repositories), relative
+                          to the Deriva home folder, the same folder the session lists.
         """
         if workspace_dir is None:
-            config = _load_config()
-            workspace_dir = config.get("workspace_dir", "workspace/repositories")
+            workspace_dir = RepositorySettings().workspace_dir
 
         ws_path = Path(workspace_dir)
         if not ws_path.is_absolute():

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/cli/cli.py

@@ -37,7 +37,7 @@ from deriva.cli.commands.run import (
     _print_pipeline_result,
 )
 from deriva.cli.progress import create_progress_reporter
-from deriva.services import about, derivation
+from deriva.services import ConfigDatabaseBusy, about, derivation
 from deriva.services.session import PipelineSession
 
 # Create main app
@@ -371,6 +371,10 @@ def main() -> int:
         return 0
     except SystemExit as e:
         return e.code if isinstance(e.code, int) else 1
+    except ConfigDatabaseBusy as e:
+        # The studio or another run holds the config database: say so in one line, without a traceback
+        typer.echo(f"Error: {e}", err=True)
+        return 1
 
 
 if __name__ == "__main__":

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/cli/commands/config.py

@@ -233,11 +233,18 @@ def config_update(
         int | None,
         typer.Option("--max-candidates", help="Maximum candidates for derivation"),
     ] = None,
+    sequence: Annotated[
+        int | None,
+        typer.Option("--sequence", min=0, help="New place in its phase (derivation only)"),
+    ] = None,
 ) -> None:
     """Update a configuration with versioning."""
     if step_type not in ("extraction", "derivation"):
         typer.echo("Error: step_type must be 'extraction' or 'derivation'", err=True)
         raise typer.Exit(1)
+    if sequence is not None and step_type != "derivation":
+        typer.echo("Error: --sequence moves derivation steps only", err=True)
+        raise typer.Exit(1)
 
     # Read instruction from file if provided
     if instruction_file:
@@ -286,6 +293,7 @@ def config_update(
                 batch_size=batch_size,
                 max_candidates=max_candidates,
                 temperature=temperature,
+                sequence=sequence,
             )
         elif step_type == "extraction":
             result = config.create_extraction_config_version(
@@ -307,6 +315,8 @@ def config_update(
             typer.echo(f"  Version: {result['old_version']} -> {result['new_version']}")
             if params:
                 typer.echo("  Params: updated")
+            if sequence is not None:
+                typer.echo(f"  Sequence: {sequence}")
         else:
             typer.echo(f"Error: {result.get('error', 'Unknown error')}", err=True)
             raise typer.Exit(1)
@@ -330,7 +340,8 @@ def config_sequence(
     """Update the execution sequence of derivation steps.
 
     Reorders steps based on the provided order list. Each step's sequence
-    number is set to its position in the list (1-indexed).
+    number is set to its position in the list (1-indexed); a step that moves
+    gets a new config version, so every reorder is recorded.
 
     Example (ArchiMate bottom-up: Technology -> Application -> Business):
 

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/cli/commands/repo.py

@@ -56,7 +56,7 @@ def repo_list(
             typer.echo("\nNo repositories found.")
             typer.echo(f"Workspace: {session.workspace_dir}")
             typer.echo("\nClone a repository with:")
-            typer.echo("  deriva repo clone <url>")
+            typer.echo("  deriva-cli repo clone <url>")
             return
 
         typer.echo(f"\n{'=' * 60}")

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/cli/commands/run.py

@@ -102,6 +102,10 @@ def _print_pipeline_result(result: dict) -> None:
 
     if result.get("errors"):
         typer.echo(f"\nTotal errors: {len(result['errors'])}")
+        for err in result["errors"][:10]:
+            typer.echo(f"  - {err}")
+        if len(result["errors"]) > 10:
+            typer.echo(f"  ... and {len(result['errors']) - 10} more")
 
 
 @app.callback(invoke_without_command=True)

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/modules/analysis/semantic_matching.py

@@ -334,17 +334,29 @@ def parse_exchange_format_xml(
     # The level property's definition, if the file declares one
     level_refs = {d.get("identifier") for d in root.iterfind(f"{_tag('propertyDefinitions')}/{_tag('propertyDefinition')}") if d.findtext(_tag("name")) == "level"}
 
-    def _level_of(elem: ET.Element) -> str:
+    def _levels_of(elem: ET.Element) -> set[str]:
+        """The element's levels: a set written as one value; "architect" (earlier exports) is enterprise; none: enterprise."""
         for prop in elem.iterfind(f"{_tag('properties')}/{_tag('property')}"):
             if prop.get("propertyDefinitionRef") in level_refs:
-                return prop.findtext(_tag("value")) or "architect"
-        return "architect"
+                text: str = prop.findtext(_tag("value")) or ""
+                values = set(text.split())
+                if not values:
+                    values = {"enterprise"}
+                if "architect" in values:
+                    values = (values - {"architect"}) | {"enterprise"}
+                return {str(v) for v in values}
+        return {"enterprise"}
+
+    def _at_level(elem: ET.Element) -> bool:
+        levels = _levels_of(elem)
+        # "architect": every derived element (any level but detail)
+        return bool(levels - {"detail"}) if level == "architect" else level in levels
 
     # Find elements section
     elements_section = root.find(_tag("elements"))
     if elements_section is not None:
         for elem in elements_section:
-            if level is not None and _level_of(elem) != level:
+            if level is not None and not _at_level(elem):
                 continue
             elem_type = elem.get("{http://www.w3.org/2001/XMLSchema-instance}type", "")
             elem_id = elem.get("identifier", "")

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/modules/derivation/base.py

@@ -15,6 +15,7 @@ import json
 import logging
 import re
 from collections import defaultdict
+from collections.abc import Iterable
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, cast
 
@@ -2306,6 +2307,9 @@ class RoleConfig:
     # element_per "unit" only: roles a deployable unit shows itself, (unit property, role key). A unit whose
     # property lists files (such as webEntries) gets that role's element with those files as members, no call
     unit_roles: tuple[tuple[str, str], ...] = ()
+    # Graph labels in the order their candidates claim a structure name (two candidates with one structure name: the
+    # earlier label keeps it, so a unit is never left out for a module beside it); empty: the step's ranking decides
+    name_priority: tuple[str, ...] = ()
 
 
 ROLE_SCHEMA: dict[str, Any] = {
@@ -2449,6 +2453,15 @@ def element_identifier(element_type: str, source_id: str) -> str:
     return sanitize_identifier(f"{prefix}_{tail}")
 
 
+def candidate_identifier(element_type: str, source_id: str, sources: Iterable[str]) -> str:
+    """``element_identifier`` among the step's candidate sources: a module whose plain identifier is a unit's (the
+    unit's folder, with modules inside) keeps its kind in it, so the unit keeps the plain one."""
+    identifier = element_identifier(element_type, source_id)
+    if source_id.startswith("module::") and any(s.startswith(UNIT_PREFIX) and element_identifier(element_type, s) == identifier for s in sources):
+        return sanitize_identifier(f"{identifier.split('_', 1)[0]}_module::{source_id.split('::', 2)[2]}")
+    return identifier
+
+
 def build_element(
     derived: dict[str, Any],
     element_type: str,
@@ -2486,7 +2499,7 @@ def build_element(
     if not name:
         return {"success": False, "errors": [f"Empty name for source {source_id!r}"]}
 
-    identifier = element_identifier(element_type, source_id)
+    identifier = candidate_identifier(element_type, source_id, source_names)
     # Clamp confidence to [0.0, 1.0] range (LLM may return out-of-range values)
     confidence = clamp_confidence(derived.get("confidence"))
 

{deriva_cli-0.8.2 → deriva_cli-0.8.3}/deriva/modules/derivation/detail_level.py

@@ -5,7 +5,7 @@ The architect level is the derived model. Its members, kept as lineage, become d
 - a data domain (DataObject) composes its entities (DataObject);
 - a channel interface (ApplicationInterface) composes its endpoint members (ApplicationInterface);
 - the environment (Node) is assigned to an artifact per deployed container, which realizes the component of the
-  unit it deploys;
+  unit it deploys; where the deployment is a service node of its own, that node is assigned to the artifact;
 - a mainframe unit (ApplicationComponent) composes its programs (ApplicationComponent);
 - a lifecycle's states stay a property of its process (the hand-off states are already events).
 
@@ -46,6 +46,7 @@ def detail_level(elements: list[dict[str, Any]], lineage: DetailLineage) -> Deta
     out = DetailLevel()
     seen: set[str] = set()
     component_of = {str((e.get("properties") or {}).get("source")): e["identifier"] for e in elements if e.get("element_type") == "ApplicationComponent"}
+    service_node = {str((e.get("properties") or {}).get("source")): e["identifier"] for e in elements if e.get("element_type") == "Node"}
 
     def member(element_type: str, identity: str, name: str, parent: str, source: str) -> str:
         identifier = element_identifier(element_type, f"detail::{identity}")
@@ -69,8 +70,9 @@ def detail_level(elements: list[dict[str, Any]], lineage: DetailLineage) -> Deta
                     out.relationships.append(_relationship("Composition", parent, child))
         elif kind == "Node":
             for deployment, name, unit in lineage.deployments.get(source, []):
-                artifact = member("Artifact", deployment, name, parent, deployment)
-                out.relationships.append(_relationship("Assignment", parent, artifact))
+                holder = service_node.get(deployment, parent)
+                artifact = member("Artifact", deployment, name, holder, deployment)
+                out.relationships.append(_relationship("Assignment", holder, artifact))
                 if unit and unit in component_of:
                     out.relationships.append(_relationship("Realization", artifact, component_of[unit]))
         elif kind == "ApplicationComponent":