Refactor Constructor and ServiceNow to use SDK Version 0.2.0 (#7)

* Refactor Constructor and ServiceNow to use SDK Version 0.2.0

* updated readmes

Author: ryanm101

README.md

@@ -7,14 +7,25 @@ Unified tooling for the **System Capability Protocol** (SCP). This monorepo cont
 ## Packages
 
 ### [constructor](./packages/constructor)
+
 **Core tool for architecture definition and graph building**
 
-Scan repositories for `scp.yaml` manifests, validate them, build dependency graphs, and export to various formats (JSON, Mermaid, Neo4j).
+Scan repositories for `scp.yaml` manifests, validate them, build dependency graphs, and export to various formats (JSON, Mermaid, Neo4j, OpenC2).
 
 ```bash
 uv run scp-cli scan ./repos --export mermaid
 ```
 
+### [servicenow](./packages/vendor/servicenow)
+
+**ServiceNow CMDB integration**
+
+Sync SCP architecture graphs to ServiceNow Configuration Management Database (CMDB).
+
+```bash
+scp-servicenow cmdb sync graph.json
+```
+
 ## Quick Start
 
 ```bash
@@ -34,26 +45,14 @@ Run `make help` to see all available commands
 
 ## Architecture
 
-```
-SCP Ecosystem
-│
-├── scp-definition (separate repo)
-│   └── Specification, schemas, examples
-│
-└── scp-integrations (this monorepo)
-    │
-    ├── constructor (scan → validate → graph)
-    │   ├── Local scanner
-    │   ├── GitHub scanner
-    │   ├── Validator
-    │   └── Exporters (JSON, Mermaid, Neo4j)
-```
+**Built on [scp-sdk](https://github.com/krackenservices/scp-sdk) 0.2.0** - All packages use the SDK for manifest parsing, validation, and graph operations.
 
 ## What is SCP?
 
-The **System Capability Protocol** provides a declarative manifest format (`scp.yaml`) that describes what a system *should* be, complementing OpenTelemetry's view of what *is happening*.
+The **System Capability Protocol** provides a declarative manifest format (`scp.yaml`) that describes what a system _should_ be, complementing OpenTelemetry's view of what _is happening_.
 
 This enables:
+
 - **LLM Reasoning**: Change impact analysis and migration planning
 - **Architecture Discovery**: Auto-generate org-wide system maps
 - **Theory vs Reality**: Diff declared dependencies against OTel traces
@@ -75,4 +74,3 @@ uv run pytest
 ## License
 
 MIT
-

packages/constructor/pyproject.toml

@@ -5,7 +5,7 @@ description = "Build architecture models from scp.yaml files"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    "scp-sdk>=0.1.0",
+    "scp-sdk>=0.2.0",
     "typer>=0.9",
     "rich>=13.0",
     "neo4j>=5.0",

packages/constructor/src/scp_constructor/export.py

@@ -2,106 +2,25 @@
 
 from typing import Any
 
-from scp_sdk.core.models import SCPManifest
+from scp_sdk import (
+    SCPManifest,
+    export_graph_json,
+    import_graph_json,
+)
 
 
 def export_json(manifests: list[SCPManifest]) -> dict[str, Any]:
     """Export manifests to a JSON-serializable graph structure.
 
+    This is a wrapper around scp_sdk.export_graph_json() for backward compatibility.
+
     Args:
         manifests: List of SCP manifests
 
     Returns:
         Dictionary with nodes and edges lists
     """
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    system_nodes: dict[str, dict] = {}  # Track by URN for stub replacement
-
-    for manifest in manifests:
-        urn = manifest.system.urn
-
-        # Add or update system node (replaces stub if exists)
-        system_nodes[urn] = {
-            "id": urn,
-            "type": "System",
-            "name": manifest.system.name,
-            "tier": manifest.system.classification.tier
-            if manifest.system.classification
-            else None,
-            "domain": manifest.system.classification.domain
-            if manifest.system.classification
-            else None,
-            "team": manifest.ownership.team if manifest.ownership else None,
-            "contacts": [
-                {"type": c.type, "ref": c.ref} for c in manifest.ownership.contacts
-            ]
-            if manifest.ownership and manifest.ownership.contacts
-            else [],
-            "escalation": manifest.ownership.escalation if manifest.ownership else [],
-        }
-
-        # Add dependency edges (create stub only if not already known)
-        if manifest.depends:
-            for dep in manifest.depends:
-                # Create stub node for dependency target if not seen
-                if dep.system not in system_nodes:
-                    system_nodes[dep.system] = {
-                        "id": dep.system,
-                        "type": "System",
-                        "name": dep.system.split(":")[-1],  # Extract name from URN
-                        "stub": True,
-                    }
-
-                edges.append(
-                    {
-                        "from": urn,
-                        "to": dep.system,
-                        "type": "DEPENDS_ON",
-                        "capability": dep.capability,
-                        "criticality": dep.criticality,
-                        "failure_mode": dep.failure_mode,
-                    }
-                )
-
-        # Add capability nodes and PROVIDES edges
-        if manifest.provides:
-            for cap in manifest.provides:
-                cap_id = f"{urn}:{cap.capability}"
-                cap_node: dict[str, Any] = {
-                    "id": cap_id,
-                    "type": "Capability",
-                    "name": cap.capability,
-                    "capability_type": cap.type,
-                }
-                # Include security extension if present
-                if cap.x_security:
-                    cap_node["x_security"] = {
-                        "actuator_profile": cap.x_security.actuator_profile,
-                        "actions": cap.x_security.actions,
-                        "targets": cap.x_security.targets,
-                    }
-                nodes.append(cap_node)
-                edges.append(
-                    {
-                        "from": urn,
-                        "to": cap_id,
-                        "type": "PROVIDES",
-                    }
-                )
-
-    # Combine system nodes (from dict) with capability nodes (from list)
-    all_nodes = list(system_nodes.values()) + nodes
-
-    return {
-        "nodes": all_nodes,
-        "edges": edges,
-        "meta": {
-            "systems_count": len(system_nodes),
-            "capabilities_count": len(nodes),
-            "dependencies_count": len([e for e in edges if e["type"] == "DEPENDS_ON"]),
-        },
-    }
+    return export_graph_json(manifests)
 
 
 def export_mermaid(manifests: list[SCPManifest], direction: str = "LR") -> str:
@@ -342,6 +261,8 @@ def export_openc2(manifests: list[SCPManifest]) -> dict[str, Any]:
 def import_json(data: dict[str, Any]) -> list[SCPManifest]:
     """Import manifests from a previously exported JSON graph.
 
+    This is a wrapper around scp_sdk.import_graph_json() for backward compatibility.
+
     Reconstructs SCPManifest objects from the JSON export format,
     allowing transformation to other formats without re-scanning.
 
@@ -351,108 +272,4 @@ def import_json(data: dict[str, Any]) -> list[SCPManifest]:
     Returns:
         List of reconstructed SCP manifests
     """
-    from scp_sdk.core.models import (
-        System,
-        Classification,
-        Ownership,
-        Capability,
-        Dependency,
-        SecurityExtension,
-    )
-
-    manifests: list[SCPManifest] = []
-    nodes = data.get("nodes", [])
-    edges = data.get("edges", [])
-
-    # Build lookup maps
-    system_nodes = {
-        n["id"]: n for n in nodes if n.get("type") == "System" and not n.get("stub")
-    }
-    capability_nodes = {n["id"]: n for n in nodes if n.get("type") == "Capability"}
-
-    # Group edges by source system
-    provides_by_system: dict[str, list[dict]] = {}
-    depends_by_system: dict[str, list[dict]] = {}
-
-    for edge in edges:
-        if edge["type"] == "PROVIDES":
-            provides_by_system.setdefault(edge["from"], []).append(edge)
-        elif edge["type"] == "DEPENDS_ON":
-            depends_by_system.setdefault(edge["from"], []).append(edge)
-
-    # Reconstruct manifests
-    for urn, node in system_nodes.items():
-        # Build classification
-        classification = None
-        if node.get("tier") or node.get("domain"):
-            classification = Classification(
-                tier=node.get("tier"),
-                domain=node.get("domain"),
-            )
-
-        # Build ownership
-        ownership = None
-        if node.get("team"):
-            from .models import Contact
-
-            contacts = []
-            if node.get("contacts"):
-                for c in node["contacts"]:
-                    contacts.append(Contact(type=c["type"], ref=c["ref"]))
-
-            ownership = Ownership(
-                team=node["team"],
-                contacts=contacts if contacts else None,
-                escalation=node.get("escalation"),
-            )
-
-        # Build capabilities
-        provides = []
-        for edge in provides_by_system.get(urn, []):
-            cap_node = capability_nodes.get(edge["to"])
-            if cap_node:
-                # Check for security extension in capability node
-                x_security = None
-                if cap_node.get("x_security"):
-                    sec = cap_node["x_security"]
-                    x_security = SecurityExtension(
-                        actuator_profile=sec.get("actuator_profile"),
-                        actions=sec.get("actions", []),
-                        targets=sec.get("targets", []),
-                    )
-
-                provides.append(
-                    Capability(
-                        capability=cap_node["name"],
-                        type=cap_node.get("capability_type", "rest"),
-                        x_security=x_security,
-                    )
-                )
-
-        # Build dependencies
-        depends = []
-        for edge in depends_by_system.get(urn, []):
-            depends.append(
-                Dependency(
-                    system=edge["to"],
-                    capability=edge.get("capability"),
-                    type="rest",  # Default, as type isn't stored in edge
-                    criticality=edge.get("criticality", "required"),
-                    failure_mode=edge.get("failure_mode"),
-                )
-            )
-
-        manifest = SCPManifest(
-            scp="0.1.0",
-            system=System(
-                urn=urn,
-                name=node["name"],
-                classification=classification,
-            ),
-            ownership=ownership,
-            provides=provides if provides else None,
-            depends=depends if depends else None,
-        )
-        manifests.append(manifest)
-
-    return manifests
+    return import_graph_json(data)