Architectural Intent Graph
The Architectural Intent Graph is the semantic backbone of NeoArc Studio. A comprehensive set of node and edge types form a complete traceability network connecting every artefact in the workspace: pages, diagrams, schemas, APIs (REST, GraphQL, gRPC, AsyncAPI, Webhooks, MCP), model entities, views, and governance blocks. This graph powers impact analysis, data lineage, governance measurement, and deprecation tracking.
When you add a schema field, you are creating a node. When you embed a diagram in a page, you are creating an edge. When you map a schema field to a model property, you are creating a lineage relationship. When a risk block references a model entity, you are creating a governance edge. Everything you do in NeoArc Studio contributes to a semantic graph that captures the intent behind your architecture.
Most users never interact with the Intent Graph directly. They work with pages, diagrams, schemas, and APIs. But beneath every action lies this graph structure, enabling capabilities that traditional documentation tools cannot provide: impact analysis that traces a field rename across every API type, data lineage from API surface to database column, governance measurement that counts which entities have risk documentation, and deprecation tracking that identifies every active reference to a retired component.
Node Types
The Intent Graph tracks every artefact in the workspace as a typed node. Nodes range from high-level documents to individual fields and properties, covering content, diagrams, the data model, views, schemas, all API types (REST, GraphQL, gRPC, AsyncAPI, Webhooks, MCP), and graph diagram elements.
Edge Types
Relationships between nodes are captured as typed edges, each with specific semantic meaning. Together, they form the traceability network, covering lineage and mapping, references and dependencies, view and model integration, multi-domain projections, and governance and lifecycle.
How the Graph Powers the System
The Intent Graph is not a feature you use directly. It is the infrastructure that makes every other feature work.
Graph Data Structure
The Intent Graph uses adjacency maps for O(1) edge lookups in both directions.
| Component | Purpose |
|---|---|
| edges[] | Array of all edges in the graph |
| outgoing Map | Node ID to outgoing edges. O(1) lookup for 'what does this node depend on?' |
| incoming Map | Node ID to incoming edges. O(1) lookup for 'what depends on this node?' |
| nodeLabels Map | Node ID to human-readable label for display |
| nodeTypes Map | Node ID to IntentNodeType for type-filtered queries |
| nodeSourcePaths Map | Node ID to workspace-relative file path for navigation |
| entityTypes Map | Entity node ID to entity type string (risk, security-control, etc.) |
| nodeMetadata Map | Node ID to metadata (projections, structural hash, lifecycle status) |
Query Capabilities
The Intent Graph service provides a rich query API for traversing relationships.
| Method | Purpose |
|---|---|
| getOutgoing(id, edgeType?) | Find all edges leaving a node, optionally filtered by edge type |
| getIncoming(id, edgeType?) | Find all edges entering a node, optionally filtered by edge type |
| getImpact(id) | BFS traversal to find all nodes affected by changes to this node |
| getLineage(schemaFieldId) | Trace a schema field back to its model property source |
| getPropertyProjections(entityId, propertyId) | Find all projection edges for a property across all domains |
| getPropertyProjectionImpact(entityId, propertyId) | Impact analysis for property rename across all projections |
| getUnprojectedProperties(entityId, domain) | Find properties not projected to a specific domain |
| getNodeStatus(id) | Get lifecycle status (active, planned, deprecated) |
| getNodeHash(id) | Get structural hash for drift detection |
| searchNodes(query, typeFilter?) | Full-text search across all node labels with optional type filtering |