sysprom 1.14.0 → 1.15.0

package/dist/src/operations/infer-derived.d.ts

@@ -0,0 +1,375 @@
+import * as z from "zod";
+/**
+ * A derived relationship inferred from transitive closure or composition.
+ */
+declare const DerivedRelationship: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    type: z.ZodString;
+    derivedFrom: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+    derivationType: z.ZodEnum<{
+        transitive: "transitive";
+        composite: "composite";
+        inverse: "inverse";
+    }>;
+}, z.core.$strip>;
+/** A derived relationship inferred from the graph. */
+export type DerivedRelationship = z.infer<typeof DerivedRelationship>;
+/**
+ * Output schema for inferDerivedOp.
+ */
+declare const DerivedOutput: z.ZodObject<{
+    derivedRelationships: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodString;
+        derivedFrom: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strip>>;
+        derivationType: z.ZodEnum<{
+            transitive: "transitive";
+            composite: "composite";
+            inverse: "inverse";
+        }>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        transitive: z.ZodNumber;
+        composite: z.ZodNumber;
+        inverse: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Output of derived relationships inference operation. */
+export type DerivedOutput = z.infer<typeof DerivedOutput>;
+/**
+ * Infer derived relationships from the graph structure.
+ *
+ * Computes transitive closure for hierarchical relationships, derives
+ * inverse relationships, and identifies composite patterns.
+ */
+export declare const inferDerivedOp: import("./define-operation.js").DefinedOperation<z.ZodObject<{
+    doc: z.ZodObject<{
+        $schema: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            doc_type: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+        }, z.core.$loose> & {
+            is(value: unknown): value is {
+                [x: string]: unknown;
+                title?: string | undefined;
+                doc_type?: string | undefined;
+                scope?: string | undefined;
+                status?: string | undefined;
+                version?: string | number | undefined;
+            };
+        }>;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                intent: "intent";
+                concept: "concept";
+                capability: "capability";
+                element: "element";
+                realisation: "realisation";
+                invariant: "invariant";
+                principle: "principle";
+                policy: "policy";
+                protocol: "protocol";
+                stage: "stage";
+                role: "role";
+                gate: "gate";
+                mode: "mode";
+                artefact: "artefact";
+                artefact_flow: "artefact_flow";
+                decision: "decision";
+                change: "change";
+                view: "view";
+                milestone: "milestone";
+                version: "version";
+            }> & {
+                is(value: unknown): value is "intent" | "concept" | "capability" | "element" | "realisation" | "invariant" | "principle" | "policy" | "protocol" | "stage" | "role" | "gate" | "mode" | "artefact" | "artefact_flow" | "decision" | "change" | "view" | "milestone" | "version";
+            };
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
+            status: z.ZodOptional<z.ZodEnum<{
+                deprecated: "deprecated";
+                proposed: "proposed";
+                accepted: "accepted";
+                active: "active";
+                implemented: "implemented";
+                adopted: "adopted";
+                defined: "defined";
+                introduced: "introduced";
+                in_progress: "in_progress";
+                complete: "complete";
+                consolidated: "consolidated";
+                experimental: "experimental";
+                retired: "retired";
+                superseded: "superseded";
+                abandoned: "abandoned";
+                deferred: "deferred";
+            }> & {
+                is(value: unknown): value is "deprecated" | "proposed" | "accepted" | "active" | "implemented" | "adopted" | "defined" | "introduced" | "in_progress" | "complete" | "consolidated" | "experimental" | "retired" | "superseded" | "abandoned" | "deferred";
+            }>;
+            lifecycle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>>;
+            context: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                };
+            }, z.core.$loose> & {
+                is(value: unknown): value is {
+                    [x: string]: unknown;
+                    id: string;
+                    description: string | string[];
+                };
+            }>>;
+            selected: z.ZodOptional<z.ZodString>;
+            rationale: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
+            scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    link: "link";
+                    add: "add";
+                    update: "update";
+                    remove: "remove";
+                }>;
+                target: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                }>;
+            }, z.core.$loose> & {
+                is(value: unknown): value is {
+                    [x: string]: unknown;
+                    type: "link" | "add" | "update" | "remove";
+                    target?: string | undefined;
+                    description?: string | string[] | undefined;
+                };
+            }>>;
+            plan: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                description: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                };
+                done: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            }, z.core.$loose> & {
+                is(value: unknown): value is {
+                    [x: string]: unknown;
+                    description: string | string[];
+                    done?: boolean | undefined;
+                };
+            }>>;
+            propagation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            includes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+            external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                role: z.ZodEnum<{
+                    output: "output";
+                    input: "input";
+                    context: "context";
+                    evidence: "evidence";
+                    source: "source";
+                    standard: "standard";
+                    prior_art: "prior_art";
+                }> & {
+                    is(value: unknown): value is "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                };
+                identifier: z.ZodString;
+                description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                }>;
+                node_id: z.ZodOptional<z.ZodString>;
+                internalised: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                    is(value: unknown): value is string | string[];
+                }>;
+            }, z.core.$strip> & {
+                is(value: unknown): value is {
+                    role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                    identifier: string;
+                    description?: string | string[] | undefined;
+                    node_id?: string | undefined;
+                    internalised?: string | string[] | undefined;
+                };
+            }>>;
+            readonly subsystem: z.ZodOptional<z.ZodObject</*elided*/ any, z.core.$strip>>;
+        }, z.core.$loose>>;
+        relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodEnum<{
+                refines: "refines";
+                realises: "realises";
+                implements: "implements";
+                depends_on: "depends_on";
+                constrained_by: "constrained_by";
+                affects: "affects";
+                supersedes: "supersedes";
+                must_preserve: "must_preserve";
+                performs: "performs";
+                part_of: "part_of";
+                precedes: "precedes";
+                must_follow: "must_follow";
+                blocks: "blocks";
+                routes_to: "routes_to";
+                governed_by: "governed_by";
+                modifies: "modifies";
+                triggered_by: "triggered_by";
+                applies_to: "applies_to";
+                produces: "produces";
+                consumes: "consumes";
+                transforms_into: "transforms_into";
+                selects: "selects";
+                requires: "requires";
+                disables: "disables";
+            }> & {
+                is(value: unknown): value is "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
+            };
+            description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
+        }, z.core.$loose> & {
+            is(value: unknown): value is {
+                [x: string]: unknown;
+                from: string;
+                to: string;
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
+                description?: string | string[] | undefined;
+            };
+        }>>;
+        external_references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<{
+                output: "output";
+                input: "input";
+                context: "context";
+                evidence: "evidence";
+                source: "source";
+                standard: "standard";
+                prior_art: "prior_art";
+            }> & {
+                is(value: unknown): value is "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+            };
+            identifier: z.ZodString;
+            description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
+            node_id: z.ZodOptional<z.ZodString>;
+            internalised: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]> & {
+                is(value: unknown): value is string | string[];
+            }>;
+        }, z.core.$strip> & {
+            is(value: unknown): value is {
+                role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                identifier: string;
+                description?: string | string[] | undefined;
+                node_id?: string | undefined;
+                internalised?: string | string[] | undefined;
+            };
+        }>>;
+    }, z.core.$strip> & {
+        is(value: unknown): value is {
+            nodes: {
+                [x: string]: unknown;
+                id: string;
+                type: "intent" | "concept" | "capability" | "element" | "realisation" | "invariant" | "principle" | "policy" | "protocol" | "stage" | "role" | "gate" | "mode" | "artefact" | "artefact_flow" | "decision" | "change" | "view" | "milestone" | "version";
+                name: string;
+                description?: string | string[] | undefined;
+                status?: "deprecated" | "proposed" | "accepted" | "active" | "implemented" | "adopted" | "defined" | "introduced" | "in_progress" | "complete" | "consolidated" | "experimental" | "retired" | "superseded" | "abandoned" | "deferred" | undefined;
+                lifecycle?: Record<string, string | boolean> | undefined;
+                context?: string | string[] | undefined;
+                options?: {
+                    [x: string]: unknown;
+                    id: string;
+                    description: string | string[];
+                }[] | undefined;
+                selected?: string | undefined;
+                rationale?: string | string[] | undefined;
+                scope?: string[] | undefined;
+                operations?: {
+                    [x: string]: unknown;
+                    type: "link" | "add" | "update" | "remove";
+                    target?: string | undefined;
+                    description?: string | string[] | undefined;
+                }[] | undefined;
+                plan?: {
+                    [x: string]: unknown;
+                    description: string | string[];
+                    done?: boolean | undefined;
+                }[] | undefined;
+                propagation?: Record<string, boolean> | undefined;
+                includes?: string[] | undefined;
+                input?: string | undefined;
+                output?: string | undefined;
+                external_references?: {
+                    role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                    identifier: string;
+                    description?: string | string[] | undefined;
+                    node_id?: string | undefined;
+                    internalised?: string | string[] | undefined;
+                }[] | undefined;
+                subsystem?: /*elided*/ any | undefined;
+            }[];
+            $schema?: string | undefined;
+            metadata?: {
+                [x: string]: unknown;
+                title?: string | undefined;
+                doc_type?: string | undefined;
+                scope?: string | undefined;
+                status?: string | undefined;
+                version?: string | number | undefined;
+            } | undefined;
+            relationships?: {
+                [x: string]: unknown;
+                from: string;
+                to: string;
+                type: "refines" | "realises" | "implements" | "depends_on" | "constrained_by" | "affects" | "supersedes" | "must_preserve" | "performs" | "part_of" | "precedes" | "must_follow" | "blocks" | "routes_to" | "governed_by" | "modifies" | "triggered_by" | "applies_to" | "produces" | "consumes" | "transforms_into" | "selects" | "requires" | "disables";
+                description?: string | string[] | undefined;
+            }[] | undefined;
+            external_references?: {
+                role: "output" | "input" | "context" | "evidence" | "source" | "standard" | "prior_art";
+                identifier: string;
+                description?: string | string[] | undefined;
+                node_id?: string | undefined;
+                internalised?: string | string[] | undefined;
+            }[] | undefined;
+        };
+    };
+}, z.core.$strip>, z.ZodObject<{
+    derivedRelationships: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodString;
+        derivedFrom: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strip>>;
+        derivationType: z.ZodEnum<{
+            transitive: "transitive";
+            composite: "composite";
+            inverse: "inverse";
+        }>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        transitive: z.ZodNumber;
+        composite: z.ZodNumber;
+        inverse: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>>;
+export {};

package/dist/src/operations/infer-derived.js

@@ -0,0 +1,158 @@
+import * as z from "zod";
+import { defineOperation } from "./define-operation.js";
+import { SysProMDocument } from "../schema.js";
+/**
+ * A derived relationship inferred from transitive closure or composition.
+ */
+const DerivedRelationship = z.object({
+    from: z.string(),
+    to: z.string(),
+    type: z.string(),
+    derivedFrom: z.array(z.object({
+        from: z.string(),
+        to: z.string(),
+        type: z.string(),
+    })),
+    derivationType: z.enum(["transitive", "composite", "inverse"]),
+});
+/**
+ * Output schema for inferDerivedOp.
+ */
+const DerivedOutput = z.object({
+    derivedRelationships: z.array(DerivedRelationship),
+    summary: z.object({
+        transitive: z.number(),
+        composite: z.number(),
+        inverse: z.number(),
+        total: z.number(),
+    }),
+});
+/**
+ * Relationship types that support transitive derivation.
+ */
+const TRANSITIVE_RELATIONSHIPS = {
+    depends_on: "depends_on",
+    refines: "refines",
+    part_of: "part_of",
+    precedes: "precedes",
+};
+/**
+ * Relationship types that have inverse relationships.
+ */
+const INVERSE_RELATIONSHIPS = {
+    depends_on: "enables",
+    precedes: "follows",
+    refines: "refined_by",
+    realises: "realised_by",
+    implements: "implemented_by",
+};
+/**
+ * Infer derived relationships from the graph structure.
+ *
+ * Computes transitive closure for hierarchical relationships, derives
+ * inverse relationships, and identifies composite patterns.
+ */
+export const inferDerivedOp = defineOperation({
+    name: "infer-derived",
+    description: "Infer derived relationships from transitive closure, inverses, and composites",
+    input: z.object({
+        doc: SysProMDocument,
+    }),
+    output: DerivedOutput,
+    fn: (input) => {
+        const derived = [];
+        const existingKeys = new Set((input.doc.relationships ?? []).map((r) => `${r.from}:${r.type}:${r.to}`));
+        const derivedKeys = new Set();
+        // Helper to add derived relationship if not already existing
+        const addDerived = (from, to, type, derivedFrom, derivationType) => {
+            const key = `${from}:${type}:${to}`;
+            if (existingKeys.has(key) || derivedKeys.has(key))
+                return;
+            derivedKeys.add(key);
+            derived.push({ from, to, type, derivedFrom, derivationType });
+        };
+        // 1. Transitive relationships - compute full transitive closure with path tracking
+        for (const [relType, derivedType] of Object.entries(TRANSITIVE_RELATIONSHIPS)) {
+            const rels = (input.doc.relationships ?? []).filter((r) => r.type === relType);
+            // Build adjacency list
+            const adj = new Map();
+            for (const r of rels) {
+                const targets = adj.get(r.from) ?? [];
+                targets.push(r.to);
+                adj.set(r.from, targets);
+            }
+            // For each source, find all transitively reachable targets with paths
+            for (const source of adj.keys()) {
+                // BFS to find all reachable nodes and their paths
+                const visited = new Map();
+                const queue = (adj.get(source) ?? []).map((target) => ({
+                    node: target,
+                    path: [{ from: source, to: target, type: relType }],
+                }));
+                while (queue.length > 0) {
+                    const item = queue.shift();
+                    if (!item)
+                        break;
+                    const { node: current, path } = item;
+                    // Skip if already visited (keep first/shortest path)
+                    if (visited.has(current))
+                        continue;
+                    visited.set(current, path);
+                    // Explore neighbours
+                    const neighbours = adj.get(current) ?? [];
+                    for (const neighbour of neighbours) {
+                        if (!visited.has(neighbour)) {
+                            queue.push({
+                                node: neighbour,
+                                path: [
+                                    ...path,
+                                    { from: current, to: neighbour, type: relType },
+                                ],
+                            });
+                        }
+                    }
+                }
+                // Add derived relationships from transitive closure
+                for (const [target, path] of visited) {
+                    // Only add if there's no direct relationship (path length > 1 means transitive)
+                    if (path.length > 1) {
+                        addDerived(source, target, derivedType, path, "transitive");
+                    }
+                }
+            }
+        }
+        // 2. Inverse relationships
+        for (const [relType, inverseType] of Object.entries(INVERSE_RELATIONSHIPS)) {
+            const rels = (input.doc.relationships ?? []).filter((r) => r.type === relType);
+            for (const r of rels) {
+                addDerived(r.to, r.from, inverseType, [{ from: r.from, to: r.to, type: r.type }], "inverse");
+            }
+        }
+        // 3. Composite patterns (A affects B, B depends_on C => A potentially_affects C)
+        const affectsRels = (input.doc.relationships ?? []).filter((r) => r.type === "affects");
+        const dependsRels = (input.doc.relationships ?? []).filter((r) => r.type === "depends_on");
+        const dependsMap = new Map();
+        for (const r of dependsRels) {
+            const deps = dependsMap.get(r.from) ?? [];
+            deps.push(r.to);
+            dependsMap.set(r.from, deps);
+        }
+        for (const affect of affectsRels) {
+            const deps = dependsMap.get(affect.to) ?? [];
+            for (const dep of deps) {
+                addDerived(affect.from, dep, "potentially_affects", [
+                    { from: affect.from, to: affect.to, type: "affects" },
+                    { from: affect.to, to: dep, type: "depends_on" },
+                ], "composite");
+            }
+        }
+        const summary = {
+            transitive: derived.filter((d) => d.derivationType === "transitive")
+                .length,
+            composite: derived.filter((d) => d.derivationType === "composite").length,
+            inverse: derived.filter((d) => d.derivationType === "inverse").length,
+            total: derived.length,
+        };
+        return { derivedRelationships: derived, summary };
+    },
+});