sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/index.cjs

@@ -0,0 +1,23 @@
+/**
+ * sysml-v2-lsp — SysML v2 Language Server
+ *
+ * Exports the filesystem path to the bundled language server module.
+ * Use this to start the server with vscode-languageclient:
+ *
+ *   const { serverPath } = require('sysml-v2-lsp');
+ *   const serverOptions = { module: serverPath, transport: TransportKind.ipc };
+ */
+'use strict';
+
+const path = require('path');
+
+/** Absolute path to the bundled language server entry point. */
+const serverPath = path.join(__dirname, 'dist', 'server', 'server.js');
+
+/** Absolute path to the bundled worker module (used internally by the server). */
+const workerPath = path.join(__dirname, 'dist', 'server', 'parser', 'parseWorker.js');
+
+/** Absolute path to the bundled MCP server entry point (stdio transport). */
+const mcpServerPath = path.join(__dirname, 'dist', 'server', 'mcpServer.js');
+
+module.exports = { serverPath, workerPath, mcpServerPath };

package/lsp/node_modules/sysml-v2-lsp/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "sysml-v2-lsp",
+  "displayName": "SysML v2 Language Server",
+  "description": "Language Server Protocol implementation for SysML v2, powered by ANTLR4",
+  "version": "0.7.0",
+  "publisher": "JamieD",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daltskin/sysml-v2-lsp.git"
+  },
+  "engines": {
+    "node": ">=20",
+    "vscode": "^1.85.0"
+  },
+  "categories": [
+    "Programming Languages"
+  ],
+  "keywords": [
+    "sysml",
+    "sysml2",
+    "systems modeling",
+    "mbse",
+    "lsp",
+    "language server",
+    "mcp",
+    "model context protocol"
+  ],
+  "bin": {
+    "sysml-mcp": "dist/server/mcpServer.js"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.cjs",
+      "default": "./index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/client/extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "sysml.restartServer",
+        "title": "SysML: Restart Language Server"
+      }
+    ],
+    "languages": [
+      {
+        "id": "sysml",
+        "aliases": [
+          "SysML",
+          "sysml"
+        ],
+        "extensions": [
+          ".sysml",
+          ".kerml"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "configuration": {
+      "type": "object",
+      "title": "SysML v2 Language Server",
+      "properties": {
+        "sysml.trace.server": {
+          "scope": "window",
+          "type": "string",
+          "enum": [
+            "off",
+            "messages",
+            "verbose"
+          ],
+          "default": "off",
+          "description": "Traces the communication between VS Code and the SysML language server."
+        },
+        "sysml.maxNumberOfProblems": {
+          "scope": "resource",
+          "type": "number",
+          "default": 100,
+          "description": "Maximum number of problems reported per file."
+        },
+        "sysml.inlayHints.enabled": {
+          "scope": "window",
+          "type": "boolean",
+          "default": true,
+          "description": "Enable or disable inlay hints (ghost text showing inferred types and supertypes)."
+        },
+        "sysml.library.path": {
+          "scope": "resource",
+          "type": "string",
+          "default": "",
+          "description": "Path to SysML v2 standard library directory."
+        }
+      }
+    }
+  },
+  "scripts": {
+    "generate": "antlr-ng -D language=TypeScript -o server/src/generated --generate-visitor true --generate-listener true grammar/SysMLv2Lexer.g4 grammar/SysMLv2Parser.g4",
+    "compile": "tsc -b",
+    "watch": "tsc -b -w",
+    "build": "npm run generate && npm run compile && node esbuild.mjs",
+    "build:production": "npm run clean && npm run generate && npm run compile && node esbuild.mjs --production",
+    "lint": "eslint ./clients/vscode/src ./server/src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "node ./clients/vscode/out/test/runTest.js",
+    "package": "vsce package",
+    "package:server": "npm run build:production && npm pack",
+    "clean": "rm -rf clients/vscode/out server/out dist *.vsix *.tgz",
+    "update-grammar": "curl -fsSL https://raw.githubusercontent.com/daltskin/grammars-v4/master/sysml-v2/SysMLv2Lexer.g4 -o grammar/SysMLv2Lexer.g4 && curl -fsSL https://raw.githubusercontent.com/daltskin/grammars-v4/master/sysml-v2/SysMLv2Parser.g4 -o grammar/SysMLv2Parser.g4 && echo '✅ Grammar files updated from daltskin/grammars-v4'",
+    "prepublishOnly": "npm run build:production",
+    "postinstall": "[ -f tsconfig.json ] && [ -d clients/vscode ] && cd clients/vscode && npm install && cd ../.. && cd server && npm install || true"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@types/node": "^22.0.0",
+    "@vscode/vsce": "^3.7.0",
+    "antlr-ng": "^1.0.10",
+    "esbuild": "^0.27.0",
+    "eslint": "^9.39.0",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.55.0",
+    "vite": "^7.3.0",
+    "vitest": "^4.0.0",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "zod": "^4.3.6"
+  }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>sysml.library</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+	</natures>
+</projectDescription>

package/lsp/node_modules/sysml-v2-lsp/sysml.library/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Analysis/.meta.json

@@ -0,0 +1,10 @@
+{
+  "index": {
+    "AnalysisTooling": "AnalysisTooling.sysml",
+    "SampledFunctions": "SampledFunctions.sysml",
+    "StateSpaceRepresentation": "StateSpaceRepresentation.sysml",
+    "TradeStudies": "TradeStudies.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Analysis/.project.json

@@ -0,0 +1,27 @@
+{
+  "name": "SysML Analysis Library",
+  "version": "2.0.0",
+  "description": "Standard analysis domain library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Quantities-and-Units-Library.kpar",
+      "versionConstraint": "2.0.0"
+    }
+  ]
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Analysis/AnalysisTooling.sysml

@@ -0,0 +1,34 @@
+standard library package AnalysisTooling {
+	doc
+	/*
+	 * This package contains definitions for metadata annotations related
+	 * to analysis tool integration.
+	 */
+
+	private import ScalarValues::*;
+	
+	metadata def ToolExecution {
+		doc
+		/*
+		 * ToolExecution metadata identifies an external analysis tool to be
+		 * used to implement the annotated action.
+		 */
+	
+		attribute toolName : String;
+		attribute uri : String;
+	}
+	
+	metadata def ToolVariable {
+		doc
+		/*
+		 * ToolVariable metadata is used in the context of an action that has
+		 * been annotated with ToolExecution metadata. It is used to annotate
+		 * a parameter or other feature of the action with the name of the
+		 * variable in the tool that is to correspond to the annotated
+		 * feature.
+		 */
+	
+		attribute name : String;
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Analysis/SampledFunctions.sysml

@@ -0,0 +1,119 @@
+standard library package SampledFunctions {
+	doc
+	/*
+	 * This package provides a library model of discretely sampled mathematical functions.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::Positive;
+	private import Collections::KeyValuePair;
+	private import Collections::OrderedMap;
+	private import SequenceFunctions::size;
+	private import ControlFunctions::forAll;
+	private import ControlFunctions::collect;
+	private import ControlFunctions::select;
+	
+    attribute def SamplePair :> KeyValuePair {
+		doc
+		/*
+		 * SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.
+		 */
+	
+        attribute domainValue :>> key;
+        attribute rangeValue :>> val;
+    }
+
+	attribute def SampledFunction :> OrderedMap {
+		doc
+		/*
+	     * SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled, 
+	     * uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly
+	     * decreasing.
+	     * 
+	     * It maps discrete domain values to discrete range values.
+	     * The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and 
+	     * the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.
+	     */
+	
+		attribute samples: SamplePair[0..*] ordered :>> elements;
+		
+		assert constraint {
+			// Note: Assumes the functions '<' and '>' are defined for the domain type.
+			(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or  // Strictly increasing
+            (1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) }     // Strictly decreasing
+		}
+	}
+	
+	calc def Domain { 
+		doc
+		/* 
+		 * Domain returns the sequence of the domainValues of all samples in a SampledFunction.
+		 */
+		 
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.domainValue;
+	}
+	
+	calc def Range { 
+		doc
+		/* 
+		 * Range returns the sequence of the rangeValues of all samples in a SampledFunction.
+		 */
+			
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.rangeValue;
+	}
+	
+	calc def Sample {
+		doc
+		/* 
+		 * Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.
+		 */
+		 
+		in calc calculation { in x; }
+		in attribute domainValues [0..*];
+		return sampling = new SampledFunction (
+			samples = domainValues->collect { in x; new SamplePair(x, calculation(x)) }
+		);
+	}
+	
+	calc def Interpolate {
+		doc
+		/*
+		 * An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.
+		 * If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		return attribute result;
+	}
+		
+	calc interpolateLinear : Interpolate {
+		doc
+		/*
+		 * interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		
+		private attribute domainValues = Domain(fn);
+		private attribute index : Positive[0..1] =
+			(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);
+			
+		private calc def Linear {
+			in attribute lowerSample : SamplePair;
+			in attribute upperSample : SamplePair;
+			in attribute value;
+			private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);
+			return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);				
+		}
+		
+		return result [0..1] =
+			if index == null or index == size(domainValues)? null
+			else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)
+			else Linear(fn.samples#(index+1), fn.samples#(index), value);
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Analysis/StateSpaceRepresentation.sysml

@@ -0,0 +1,143 @@
+standard library package StateSpaceRepresentation {
+	doc
+	/*
+	 * This package provides a model of the foundational state-space system representation, 
+	 * commonly used in control systems.
+	 */
+
+    private import ISQ::DurationValue;
+    private import Quantities::VectorQuantityValue;
+    private import VectorCalculations::*;
+
+    abstract attribute def StateSpace :> VectorQuantityValue;
+    abstract attribute def Input :> VectorQuantityValue;
+    abstract attribute def Output :> VectorQuantityValue;
+
+    abstract calc def GetNextState { 
+    	in input: Input; 
+    	in stateSpace: StateSpace; 
+    	in timeStep: DurationValue; 
+    	return : StateSpace;
+    }
+    abstract calc def GetOutput {
+    	in input: Input; 
+    	in stateSpace: StateSpace;
+    	return : Output;
+	}
+	
+     abstract action def StateSpaceEventDef {
+    	doc
+    	/*
+    	 * Events to be received.
+    	 */
+    }
+    action def ZeroCrossingEventDef :> StateSpaceEventDef;
+
+    item def StateSpaceItem {
+    	doc
+    	/*
+    	 * Item for SSR connection
+    	 */
+    }
+
+    abstract action def StateSpaceDynamics {
+	    doc
+	    /*
+	     * StateSpaceDynamics is the simplest form of State Space Representation,
+	     * and nextState directly computes the stateSpace of the next timestep. 
+	     */
+    
+        in attribute input: Input;
+
+        abstract calc getNextState: GetNextState;
+        abstract calc getOutput: GetOutput;
+        attribute stateSpace: StateSpace;
+
+        out attribute output: Output = getOutput(input, stateSpace);
+    }
+
+    abstract attribute def StateDerivative :> VectorQuantityValue {
+	    doc
+	    /*
+	     * The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace
+	     */
+    
+        ref stateSpace: StateSpace;
+        constraint { stateSpace.order == order }
+    }
+
+    abstract calc def GetDerivative {
+	    doc
+	    /*
+	     * Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.
+	     */
+	    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateDerivative;
+	}
+	
+    abstract calc def Integrate {
+	    doc
+	    /*
+	     * Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.
+	     * Its actual implementation should be given by a solver. 
+	     */
+    
+        in getDerivative: GetDerivative;
+        in input: Input;
+        in initialState: StateSpace;
+        in timeInterval: DurationValue;
+        return result: StateSpace;
+	}
+	
+    abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * ContinuousStateSpaceDynamics represents continuous behavior.
+	     * derivative needs to return a time derivative of stateSpace, i.e. dx/dt.
+	     */
+    
+        abstract calc getDerivative: GetDerivative;
+        calc :>> getNextState: GetNextState {
+            /* We compute nextState by Integrate defined above by giving derivative calc. */
+            calc integrate: Integrate {
+                in getDerivative = ContinuousStateSpaceDynamics::getDerivative;
+                in input = GetNextState::input;
+                in initialState = GetNextState::stateSpace;
+                in timeInterval = GetNextState::timeStep;
+           }
+           return result = integrate.result;
+        }
+
+        event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {
+        	/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */ 
+        }
+    }
+
+    abstract calc def GetDifference {
+    	doc
+	    /*
+	     * Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),
+	     * where k is the timestep number. 
+	     */
+    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateSpace;
+	}
+	
+    abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * DiscreteStateSpaceDynamics represents discrete behavior.
+	     * differences needs to return difference of the stateSpace for each timestep.
+	     */
+    
+        abstract calc getDifference: GetDifference;
+        calc :>> getNextState: GetNextState {
+            attribute diff: StateSpace = getDifference(input, stateSpace);
+            return result = stateSpace + diff;
+        }
+    }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Analysis/TradeStudies.sysml

@@ -0,0 +1,171 @@
+standard library package TradeStudies {
+	doc
+	/*
+	 * This package provides a simple framework for defining trade-off study analysis cases.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::*;
+	private import ScalarFunctions::*;
+	private import ControlFunctions::*;
+	
+	abstract calc def EvaluationFunction {
+		doc
+		/*
+		 * An EvaluationFunction is a calculation that evaluates a TradeStudy alternative,
+		 * producing a ScalarValue that can be comparted with the evaluation of other
+		 * alternatives.
+		 */
+	
+		in ref alternative : Anything {
+			doc
+			/*
+			 * The alternative to be evaluated.
+			 */
+		} 
+		
+		return attribute result : ScalarValue[1] {
+			doc
+			/*
+			 * A ScalarValue representing the evaluation of the given alternative.
+			 */
+		} 
+	}
+	
+	abstract requirement def TradeStudyObjective {
+		doc
+		/*
+		 * A TradeStudyObjective is the base definition for the objective of a TradeStudy.
+		 * The requirement is to choose from a given set of alternatives the selectedAlternative
+		 * for that has the best evaluation according to a given EvaluationFunction. What
+		 * value is considered "best" is not defined in the abstract base definition but must be
+		 * computed in any concrete specialization.
+		 */
+	
+		subject selectedAlternative : Anything {
+			doc
+			/*
+			 * The alternative that should be selected, as evaluated using the given 
+			 * ObjectiveFunction.
+			 */
+		}
+		
+		in ref alternatives : Anything[1..*] {
+			doc
+			/*
+			 * The alternatives being considered in the TradeStudy for which this TradeStudyObjective 
+			 * is the objective.
+			 */
+		}
+		
+		in calc eval : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used in evaluating the given alternatives.
+			 */
+		}
+		
+		attribute best : ScalarValue {
+			doc
+			/*
+			 * Out of the evaluation results of all the given alternatives, the one that is considered 
+			 * "best", in the sense that it is the value the selectedAlternative should have. This 
+			 * value must be computed in any concrete specialization of TradeStudyObjective.
+			 */
+		}
+				
+		require constraint { eval(selectedAlternative) == best }
+	}
+	
+	requirement def MinimizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MinimizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the minimum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+		 
+		attribute :>> best = alternatives->minimize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the minimum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	requirement def MaximizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MaximizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the maximum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+	
+		attribute :>> best = alternatives->maximize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the maximum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	abstract analysis def TradeStudy {
+		doc
+		/*
+		 * A TradeStudy is an analysis case whose subject is a set of alternatives
+		 * (at least one) and whose result is a selection of one of those alternatives.
+		 * The alternatives are evaluated based on a given ObjectiveFunction and the
+		 * selection is made such that it satisfies the objective of the TradeStudy
+		 * (which must be a TradeStudyObjective).
+		 */
+	
+		subject studyAlternatives : Anything[1..*] {
+			doc
+			/*
+			 * The set of alternatives being considered in this TradeStudy. 
+			 * 
+			 * In a TradeStudy usage, bind this feature to the actual collection of
+			 * alternatives to be considered.
+			 */
+		}
+		
+		abstract calc evaluationFunction : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used to evaluate the alternatives.
+			 * 
+			 * In a TradeStudy usage, redefine this feature to provide the desired
+			 * calculation (or bind it to a calculation usage that does so).
+			 */
+		}
+		
+		objective tradeStudyObjective : TradeStudyObjective {
+			doc
+			/*
+			 * The objective of this TradeStudy.
+			 * 
+			 * Redefine this feature to give it a definition that is a concrete
+			 * specialization of TradeStudyObjective. That can either be one of the
+			 * specializations provided in this package, or a more specific user-
+			 * defined one.
+			 */
+		
+            subject :>> selectedAlternative;
+			in ref :>> alternatives = studyAlternatives;
+			in calc :>> eval = evaluationFunction;
+		}
+		
+		return selectedAlternative : Anything = studyAlternatives->selectOne {in ref a {
+			doc
+			/*
+			 * The alternative selected by this TradeStudy, which is the one that meets the
+			 * requirement of the tradeStudyObjective.
+			 */
+		} tradeStudyObjective(selectedAlternative = a)};
+	}
+	
+}