@rengler33/prov 0.1.1

package/dist/graph.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Intent Graph implementation.
+ *
+ * The intent graph is a directed acyclic graph (DAG) that connects
+ * specifications to implementations via plans and traces.
+ *
+ * @see spec:intent-graph:v1
+ */
+import type { EntityId, NodeType, EdgeType, GraphNode, GraphEdge, Hash, Spec, Requirement, Constraint, Invariant, Plan, Decision, Step, Trace } from './types.js';
+/**
+ * Entity data that can be stored in a graph node.
+ */
+export type EntityData = Spec | Requirement | Constraint | Invariant | Plan | Decision | Step | Trace;
+/**
+ * Options for graph traversal.
+ */
+export interface TraversalOptions {
+    /** Maximum depth to traverse (default: unlimited) */
+    readonly maxDepth?: number;
+    /** Edge types to follow (default: all) */
+    readonly edgeTypes?: readonly EdgeType[];
+    /** Include the starting node in results */
+    readonly includeStart?: boolean;
+}
+/**
+ * Result of validation check.
+ */
+export interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+}
+/**
+ * Intent Graph - the central data structure for provenance tracking.
+ *
+ * @see req:graph:structure
+ */
+export declare class IntentGraph {
+    private readonly nodes;
+    private readonly edges;
+    private readonly outgoingEdges;
+    private readonly incomingEdges;
+    /**
+     * Create a new empty intent graph.
+     */
+    constructor();
+    /**
+     * Get the number of nodes in the graph.
+     */
+    get nodeCount(): number;
+    /**
+     * Get the number of edges in the graph.
+     */
+    get edgeCount(): number;
+    /**
+     * Add a node to the graph.
+     *
+     * @param id - Entity ID
+     * @param type - Node type
+     * @param data - Entity data
+     * @param hash - Optional pre-computed hash
+     */
+    addNode(id: EntityId, type: NodeType, data: EntityData, hash?: Hash): GraphNode;
+    /**
+     * Get a node by ID.
+     */
+    getNode(id: EntityId): GraphNode | undefined;
+    /**
+     * Check if a node exists.
+     */
+    hasNode(id: EntityId): boolean;
+    /**
+     * Remove a node and all its edges.
+     */
+    removeNode(id: EntityId): boolean;
+    /**
+     * Get all nodes of a specific type.
+     */
+    getNodesByType(type: NodeType): GraphNode[];
+    /**
+     * Get all nodes as an array.
+     */
+    getAllNodes(): GraphNode[];
+    /**
+     * Add an edge to the graph.
+     *
+     * @param from - Source node ID
+     * @param to - Target node ID
+     * @param type - Edge type
+     * @returns true if edge was added, false if it already exists
+     */
+    addEdge(from: EntityId, to: EntityId, type: EdgeType): boolean;
+    /**
+     * Remove an edge from the graph.
+     */
+    removeEdge(from: EntityId, to: EntityId, type: EdgeType): boolean;
+    /**
+     * Get edges going out from a node.
+     */
+    getOutgoingEdges(id: EntityId, type?: EdgeType): GraphEdge[];
+    /**
+     * Get edges coming into a node.
+     */
+    getIncomingEdges(id: EntityId, type?: EdgeType): GraphEdge[];
+    /**
+     * Get all edges.
+     */
+    getAllEdges(): GraphEdge[];
+    /**
+     * Traverse forward from a node (follow outgoing edges).
+     *
+     * @see req:graph:traversal-forward
+     */
+    traverseForward(startId: EntityId, options?: TraversalOptions): EntityId[];
+    /**
+     * Traverse backward from a node (follow incoming edges).
+     *
+     * @see req:graph:traversal-backward
+     */
+    traverseBackward(startId: EntityId, options?: TraversalOptions): EntityId[];
+    /**
+     * Internal traversal implementation using BFS.
+     */
+    private traverse;
+    /**
+     * Get all nodes reachable from a given node (forward).
+     *
+     * @see req:graph:subgraph-extraction
+     */
+    getReachableFrom(id: EntityId): EntityId[];
+    /**
+     * Get all nodes that can reach a given node (backward).
+     *
+     * @see req:graph:subgraph-extraction
+     */
+    getReachableTo(id: EntityId): EntityId[];
+    /**
+     * Get the neighborhood of a node (nodes it can reach + nodes that can reach it).
+     *
+     * @see req:graph:subgraph-extraction
+     */
+    getNeighborhood(id: EntityId): EntityId[];
+    /**
+     * Find all nodes impacted by a change to the given node.
+     *
+     * @see req:graph:impact-analysis
+     */
+    getImpact(id: EntityId): EntityId[];
+    /**
+     * Find orphan requirements (no step traces to them).
+     *
+     * @see req:graph:orphan-detection
+     */
+    getOrphanRequirements(): EntityId[];
+    /**
+     * Find orphan artifacts (no step implements them).
+     *
+     * @see req:graph:orphan-detection
+     */
+    getOrphanArtifacts(): EntityId[];
+    /**
+     * Check if the graph is a valid DAG (no cycles).
+     *
+     * @see req:graph:structure
+     */
+    isDAG(): boolean;
+    /**
+     * Validate graph consistency.
+     *
+     * @see req:graph:consistency
+     */
+    validate(): ValidationResult;
+    /**
+     * Export graph to a plain object for serialization.
+     */
+    toJSON(): {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    };
+    /**
+     * Create a graph from a plain object.
+     */
+    static fromJSON(data: {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    }): IntentGraph;
+}
+/**
+ * Add a Spec and its Requirements to the graph.
+ */
+export declare function addSpecToGraph(graph: IntentGraph, spec: Spec): void;
+/**
+ * Add a Constraint and its Invariants to the graph.
+ */
+export declare function addConstraintToGraph(graph: IntentGraph, constraint: Constraint): void;
+/**
+ * Add a Plan and its Decisions/Steps to the graph.
+ */
+export declare function addPlanToGraph(graph: IntentGraph, plan: Plan): void;
+/**
+ * Add a Trace to the graph (linking artifact to step).
+ */
+export declare function addTraceToGraph(graph: IntentGraph, trace: Trace): void;
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"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"}

package/dist/graph.js

@@ -0,0 +1,496 @@
+/**
+ * Intent Graph implementation.
+ *
+ * The intent graph is a directed acyclic graph (DAG) that connects
+ * specifications to implementations via plans and traces.
+ *
+ * @see spec:intent-graph:v1
+ */
+import { computeHash } from './hash.js';
+/**
+ * Intent Graph - the central data structure for provenance tracking.
+ *
+ * @see req:graph:structure
+ */
+export class IntentGraph {
+    nodes = new Map();
+    edges = [];
+    outgoingEdges = new Map();
+    incomingEdges = new Map();
+    /**
+     * Create a new empty intent graph.
+     */
+    constructor() { }
+    /**
+     * Get the number of nodes in the graph.
+     */
+    get nodeCount() {
+        return this.nodes.size;
+    }
+    /**
+     * Get the number of edges in the graph.
+     */
+    get edgeCount() {
+        return this.edges.length;
+    }
+    // ============================================================================
+    // Node Operations
+    // ============================================================================
+    /**
+     * Add a node to the graph.
+     *
+     * @param id - Entity ID
+     * @param type - Node type
+     * @param data - Entity data
+     * @param hash - Optional pre-computed hash
+     */
+    addNode(id, type, data, hash) {
+        const node = {
+            id,
+            type,
+            data,
+            hash: hash ?? computeHash(data),
+        };
+        this.nodes.set(id, node);
+        return node;
+    }
+    /**
+     * Get a node by ID.
+     */
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    /**
+     * Check if a node exists.
+     */
+    hasNode(id) {
+        return this.nodes.has(id);
+    }
+    /**
+     * Remove a node and all its edges.
+     */
+    removeNode(id) {
+        if (!this.nodes.has(id)) {
+            return false;
+        }
+        // Remove all edges connected to this node
+        const outgoing = this.outgoingEdges.get(id) ?? [];
+        const incoming = this.incomingEdges.get(id) ?? [];
+        for (const edge of [...outgoing, ...incoming]) {
+            this.removeEdge(edge.from, edge.to, edge.type);
+        }
+        this.nodes.delete(id);
+        this.outgoingEdges.delete(id);
+        this.incomingEdges.delete(id);
+        return true;
+    }
+    /**
+     * Get all nodes of a specific type.
+     */
+    getNodesByType(type) {
+        const result = [];
+        for (const node of this.nodes.values()) {
+            if (node.type === type) {
+                result.push(node);
+            }
+        }
+        return result;
+    }
+    /**
+     * Get all nodes as an array.
+     */
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    // ============================================================================
+    // Edge Operations
+    // ============================================================================
+    /**
+     * Add an edge to the graph.
+     *
+     * @param from - Source node ID
+     * @param to - Target node ID
+     * @param type - Edge type
+     * @returns true if edge was added, false if it already exists
+     */
+    addEdge(from, to, type) {
+        // Check for duplicate
+        const existing = this.edges.find((e) => e.from === from && e.to === to && e.type === type);
+        if (existing !== undefined) {
+            return false;
+        }
+        const edge = { from, to, type };
+        this.edges.push(edge);
+        // Update adjacency lists
+        if (!this.outgoingEdges.has(from)) {
+            this.outgoingEdges.set(from, []);
+        }
+        this.outgoingEdges.get(from)?.push(edge);
+        if (!this.incomingEdges.has(to)) {
+            this.incomingEdges.set(to, []);
+        }
+        this.incomingEdges.get(to)?.push(edge);
+        return true;
+    }
+    /**
+     * Remove an edge from the graph.
+     */
+    removeEdge(from, to, type) {
+        const index = this.edges.findIndex((e) => e.from === from && e.to === to && e.type === type);
+        if (index === -1) {
+            return false;
+        }
+        this.edges.splice(index, 1);
+        // Update adjacency lists
+        const outgoing = this.outgoingEdges.get(from);
+        if (outgoing !== undefined) {
+            const outIndex = outgoing.findIndex((e) => e.to === to && e.type === type);
+            if (outIndex !== -1) {
+                outgoing.splice(outIndex, 1);
+            }
+        }
+        const incoming = this.incomingEdges.get(to);
+        if (incoming !== undefined) {
+            const inIndex = incoming.findIndex((e) => e.from === from && e.type === type);
+            if (inIndex !== -1) {
+                incoming.splice(inIndex, 1);
+            }
+        }
+        return true;
+    }
+    /**
+     * Get edges going out from a node.
+     */
+    getOutgoingEdges(id, type) {
+        const edges = this.outgoingEdges.get(id) ?? [];
+        if (type === undefined) {
+            return [...edges];
+        }
+        return edges.filter((e) => e.type === type);
+    }
+    /**
+     * Get edges coming into a node.
+     */
+    getIncomingEdges(id, type) {
+        const edges = this.incomingEdges.get(id) ?? [];
+        if (type === undefined) {
+            return [...edges];
+        }
+        return edges.filter((e) => e.type === type);
+    }
+    /**
+     * Get all edges.
+     */
+    getAllEdges() {
+        return [...this.edges];
+    }
+    // ============================================================================
+    // Traversal Operations
+    // ============================================================================
+    /**
+     * Traverse forward from a node (follow outgoing edges).
+     *
+     * @see req:graph:traversal-forward
+     */
+    traverseForward(startId, options = {}) {
+        return this.traverse(startId, 'forward', options);
+    }
+    /**
+     * Traverse backward from a node (follow incoming edges).
+     *
+     * @see req:graph:traversal-backward
+     */
+    traverseBackward(startId, options = {}) {
+        return this.traverse(startId, 'backward', options);
+    }
+    /**
+     * Internal traversal implementation using BFS.
+     */
+    traverse(startId, direction, options) {
+        const { maxDepth, edgeTypes, includeStart = false } = options;
+        const visited = new Set();
+        const result = [];
+        const queue = [
+            { id: startId, depth: 0 },
+        ];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === undefined)
+                break;
+            const { id, depth } = current;
+            if (visited.has(id))
+                continue;
+            visited.add(id);
+            // Add to result (skip start if not included)
+            if (id !== startId || includeStart) {
+                result.push(id);
+            }
+            // Check depth limit
+            if (maxDepth !== undefined && depth >= maxDepth)
+                continue;
+            // Get edges based on direction
+            const edges = direction === 'forward'
+                ? this.getOutgoingEdges(id)
+                : this.getIncomingEdges(id);
+            // Follow edges
+            for (const edge of edges) {
+                // Filter by edge type if specified
+                if (edgeTypes !== undefined && !edgeTypes.includes(edge.type)) {
+                    continue;
+                }
+                const nextId = direction === 'forward' ? edge.to : edge.from;
+                if (!visited.has(nextId)) {
+                    queue.push({ id: nextId, depth: depth + 1 });
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get all nodes reachable from a given node (forward).
+     *
+     * @see req:graph:subgraph-extraction
+     */
+    getReachableFrom(id) {
+        return this.traverseForward(id, { includeStart: false });
+    }
+    /**
+     * Get all nodes that can reach a given node (backward).
+     *
+     * @see req:graph:subgraph-extraction
+     */
+    getReachableTo(id) {
+        return this.traverseBackward(id, { includeStart: false });
+    }
+    /**
+     * Get the neighborhood of a node (nodes it can reach + nodes that can reach it).
+     *
+     * @see req:graph:subgraph-extraction
+     */
+    getNeighborhood(id) {
+        const forward = new Set(this.getReachableFrom(id));
+        const backward = new Set(this.getReachableTo(id));
+        return [...new Set([...forward, ...backward])];
+    }
+    // ============================================================================
+    // Impact Analysis
+    // ============================================================================
+    /**
+     * Find all nodes impacted by a change to the given node.
+     *
+     * @see req:graph:impact-analysis
+     */
+    getImpact(id) {
+        return this.traverseForward(id, { includeStart: false });
+    }
+    // ============================================================================
+    // Orphan Detection
+    // ============================================================================
+    /**
+     * Find orphan requirements (no step traces to them).
+     *
+     * @see req:graph:orphan-detection
+     */
+    getOrphanRequirements() {
+        const orphans = [];
+        for (const node of this.getNodesByType('requirement')) {
+            const incoming = this.getIncomingEdges(node.id, 'traces_to');
+            if (incoming.length === 0) {
+                orphans.push(node.id);
+            }
+        }
+        return orphans;
+    }
+    /**
+     * Find orphan artifacts (no step implements them).
+     *
+     * @see req:graph:orphan-detection
+     */
+    getOrphanArtifacts() {
+        const orphans = [];
+        for (const node of this.getNodesByType('artifact')) {
+            const incoming = this.getIncomingEdges(node.id, 'implements');
+            if (incoming.length === 0) {
+                orphans.push(node.id);
+            }
+        }
+        return orphans;
+    }
+    // ============================================================================
+    // Validation
+    // ============================================================================
+    /**
+     * Check if the graph is a valid DAG (no cycles).
+     *
+     * @see req:graph:structure
+     */
+    isDAG() {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const hasCycle = (id) => {
+            visited.add(id);
+            recursionStack.add(id);
+            const edges = this.getOutgoingEdges(id);
+            for (const edge of edges) {
+                if (!visited.has(edge.to)) {
+                    if (hasCycle(edge.to)) {
+                        return true;
+                    }
+                }
+                else if (recursionStack.has(edge.to)) {
+                    return true;
+                }
+            }
+            recursionStack.delete(id);
+            return false;
+        };
+        for (const id of this.nodes.keys()) {
+            if (!visited.has(id)) {
+                if (hasCycle(id)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate graph consistency.
+     *
+     * @see req:graph:consistency
+     */
+    validate() {
+        const errors = [];
+        const warnings = [];
+        // Check for cycles
+        if (!this.isDAG()) {
+            errors.push('Graph contains cycles');
+        }
+        // Check that all edge endpoints exist
+        for (const edge of this.edges) {
+            if (!this.nodes.has(edge.from)) {
+                errors.push(`Edge references non-existent source node: ${edge.from}`);
+            }
+            if (!this.nodes.has(edge.to)) {
+                errors.push(`Edge references non-existent target node: ${edge.to}`);
+            }
+        }
+        // Check for orphan requirements
+        const orphanReqs = this.getOrphanRequirements();
+        for (const id of orphanReqs) {
+            warnings.push(`Orphan requirement (no implementation): ${id}`);
+        }
+        // Check for orphan artifacts
+        const orphanArtifacts = this.getOrphanArtifacts();
+        for (const id of orphanArtifacts) {
+            warnings.push(`Orphan artifact (no implementing step): ${id}`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    // ============================================================================
+    // Serialization
+    // ============================================================================
+    /**
+     * Export graph to a plain object for serialization.
+     */
+    toJSON() {
+        return {
+            nodes: this.getAllNodes(),
+            edges: this.getAllEdges(),
+        };
+    }
+    /**
+     * Create a graph from a plain object.
+     */
+    static fromJSON(data) {
+        const graph = new IntentGraph();
+        for (const node of data.nodes) {
+            graph.nodes.set(node.id, node);
+        }
+        for (const edge of data.edges) {
+            graph.addEdge(edge.from, edge.to, edge.type);
+        }
+        return graph;
+    }
+}
+// ============================================================================
+// Graph Building Helpers
+// ============================================================================
+/**
+ * Add a Spec and its Requirements to the graph.
+ */
+export function addSpecToGraph(graph, spec) {
+    // Add spec node
+    graph.addNode(spec.id, 'spec', spec, spec.hash);
+    // Add requirement nodes and edges
+    for (const req of spec.requirements) {
+        graph.addNode(req.id, 'requirement', req);
+        graph.addEdge(spec.id, req.id, 'contains');
+        // Add dependency edges
+        if (req.dependencies !== undefined) {
+            for (const depId of req.dependencies) {
+                graph.addEdge(req.id, depId, 'depends_on');
+            }
+        }
+    }
+}
+/**
+ * Add a Constraint and its Invariants to the graph.
+ */
+export function addConstraintToGraph(graph, constraint) {
+    // Add constraint node
+    graph.addNode(constraint.id, 'constraint', constraint, constraint.hash);
+    // Add invariant nodes and edges
+    for (const inv of constraint.invariants) {
+        graph.addNode(inv.id, 'invariant', inv);
+        graph.addEdge(constraint.id, inv.id, 'contains');
+    }
+}
+/**
+ * Add a Plan and its Decisions/Steps to the graph.
+ */
+export function addPlanToGraph(graph, plan) {
+    // Add plan node
+    graph.addNode(plan.id, 'plan', plan, plan.hash);
+    // Add derives_from edges to sources
+    for (const source of plan.sources) {
+        graph.addEdge(plan.id, source.id, 'derives_from');
+    }
+    // Add decision nodes and edges
+    for (const decision of plan.decisions) {
+        graph.addNode(decision.id, 'decision', decision);
+        graph.addEdge(plan.id, decision.id, 'contains');
+        // Add traces_to edges
+        for (const targetId of decision.tracesTo) {
+            graph.addEdge(decision.id, targetId, 'traces_to');
+        }
+    }
+    // Add step nodes and edges
+    for (const step of plan.steps) {
+        graph.addNode(step.id, 'step', step);
+        graph.addEdge(plan.id, step.id, 'contains');
+        // Add traces_to edges
+        for (const targetId of step.tracesTo) {
+            graph.addEdge(step.id, targetId, 'traces_to');
+        }
+        // Add dependency edges
+        if (step.dependencies !== undefined) {
+            for (const depId of step.dependencies) {
+                graph.addEdge(step.id, depId, 'depends_on');
+            }
+        }
+    }
+}
+/**
+ * Add a Trace to the graph (linking artifact to step).
+ */
+export function addTraceToGraph(graph, trace) {
+    // Add trace as artifact node
+    graph.addNode(trace.id, 'artifact', trace);
+    // Add implements edge from step to artifact
+    graph.addEdge(trace.step, trace.id, 'implements');
+}
+//# sourceMappingURL=graph.js.map