@ui5/mcp-server 0.1.0

package/package.json

@@ -0,0 +1,121 @@
+{
+	"name": "@ui5/mcp-server",
+	"version": "0.1.0",
+	"description": "A MCP server for UI5",
+	"author": {
+		"name": "SAP SE",
+		"email": "openui5@sap.com",
+		"url": "https://www.sap.com"
+	},
+	"license": "Apache-2.0",
+	"keywords": [
+		"openui5",
+		"sapui5",
+		"ui5",
+		"development",
+		"mcp"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/UI5/mcp-server.git"
+	},
+	"bugs": {
+		"url": "https://github.com/UI5/mcp-server/issues"
+	},
+	"bin": {
+		"ui5mcp": "bin/ui5mcp.js"
+	},
+	"type": "module",
+	"scripts": {
+		"start": "tsx src/cli.ts",
+		"inspect-mcp-server": "mcp-inspector tsx src/cli.ts",
+		"inspect-mcp-server-debug": "mcp-inspector tsx --inspect src/cli.ts",
+		"build": "npm run clean-lib && tsc -p tsconfig.build.json",
+		"build-test": "tsc --noEmit -p .",
+		"build-watch": "npm run clean-lib && tsc -w -p tsconfig.build.json",
+		"check-licenses": "licensee --errors-only",
+		"depcheck": "depcheck --ignores @commitlint/config-conventional,@istanbuljs/esm-loader-hook,rimraf,@modelcontextprotocol/inspector",
+		"hooks:pre-push": "npm run lint:commit && npm run lint && npm run depcheck",
+		"lint:commit": "commitlint -e",
+		"prepare": "node ./.husky/skip.js || husky",
+		"clean-coverage": "rimraf coverage",
+		"clean-lib": "rimraf lib",
+		"clean-test-tmp": "rimraf test/tmp",
+		"lint": "eslint .",
+		"lint-fix": "eslint . --fix",
+		"test": "npm run lint && npm run build-test && npm run coverage && npm run depcheck && npm run check-licenses",
+		"coverage": "npm run clean-coverage && nyc ava --node-arguments=\"--experimental-loader=@istanbuljs/esm-loader-hook\"",
+		"unit": "ava",
+		"unit-debug": "ava debug",
+		"unit-update-snapshots": "ava --update-snapshots",
+		"unit-watch": "ava --watch",
+		"try-create-ui5-app": "tsx test/runCreateUi5App.ts",
+		"try-create-ui5-ts-app": "tsx test/runCreateUi5TsApp.ts",
+		"update-docs": "tsx scripts/updateDocs.ts"
+	},
+	"files": [
+		"CHANGELOG.md",
+		"LICENSES/**",
+		"bin/**",
+		"lib/**",
+		"resources/**",
+		"npm-shrinkwrap.json",
+		".reuse/**"
+	],
+	"engines": {
+		"node": "^20.11.0 || >=22.0.0",
+		"npm": ">= 8"
+	},
+	"exports": {
+		".": {
+			"import": "./lib/api.js",
+			"types": "./lib/api.d.ts",
+			"default": "./lib/api.js"
+		}
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.17.4",
+		"@ui5/linter": "^1.19.0",
+		"@ui5/logger": "^4.0.1",
+		"@ui5/project": "^4.0.4",
+		"async-mutex": "^0.5.0",
+		"ejs": "^3.1.10",
+		"execa": "^9.6.0",
+		"fast-xml-parser": "^5.2.5",
+		"globby": "^14.1.0",
+		"lockfile": "^1.0.4",
+		"make-fetch-happen": "^14.0.3",
+		"semver": "^7.7.2",
+		"zod": "^3.25.76"
+	},
+	"devDependencies": {
+		"@commitlint/cli": "^19.8.1",
+		"@commitlint/config-conventional": "^19.8.1",
+		"@eslint/js": "^9.34.0",
+		"@istanbuljs/esm-loader-hook": "^0.3.0",
+		"@istanbuljs/nyc-config-typescript": "^1.0.2",
+		"@modelcontextprotocol/inspector": "^0.16.5",
+		"@stylistic/eslint-plugin": "^5.2.3",
+		"@types/ejs": "^3.1.5",
+		"@types/make-fetch-happen": "^10.0.4",
+		"@types/node": "20.16.15",
+		"@types/semver": "^7.7.0",
+		"@types/sinon": "^17.0.4",
+		"@types/yauzl-promise": "^4.0.1",
+		"@ui5-language-assistant/semantic-model-types": "^3.3.1",
+		"ava": "^6.3.0",
+		"depcheck": "^1.4.7",
+		"eslint": "^9.34.0",
+		"eslint-plugin-ava": "^15.0.1",
+		"esmock": "^2.7.2",
+		"husky": "^9.1.7",
+		"licensee": "^11.1.1",
+		"nyc": "^17.1.0",
+		"rimraf": "^6.0.1",
+		"sinon": "^21.0.0",
+		"tsx": "^4.20.5",
+		"typescript": "^5.9.2",
+		"typescript-eslint": "^8.41.0",
+		"yauzl-promise": "^4.0.0"
+	}
+}

package/resources/docs/1.136.7/00737d6c1b864dc3ab72ef56611491c4.md

@@ -0,0 +1,155 @@
+# Best Practices for Loading Modules
+
+This section provides best practices for SAPUI5 module loading patterns.
+
+These best practices are especially important when you switch from the synchronous variant of the SAPUI5 module loader to the asynchronous variant. Patterns that may have worked in synchronous module loading may lead to applications that can't start in asynchronous module loading.
+
+> ### Note:  
+> Use the `async` configuration parameter to enable asynchronous module loading via the bootstrap. For more information, see [Standard Variant for Bootstrapping](standard-variant-for-bootstrapping-91f1f45.md).
+
+## How to Define Modules
+
+Every SAPUI5 module file must contain exactly one unnamed module definition on the top level: the `sap.ui.define` call. Also, to avoid side-effects, all module-related functions must be defined within the callback function.
+
+**Example**: The following two modules are unnamed. They only contain one top-level `sap.ui.define` and can be addressed with the respective unique module name:
+
+`myLib/MyModuleA.js`
+
+```js
+sap.ui.define(function(){
+    ...
+});
+...
+```
+
+For troubleshooting information with regard to loading your module, see [Why is my Module Not Loading?](troubleshooting-for-loading-modules-4363b3f.md#loio4363b3fe3561414ca1b030afc8cd30ce__section_moduleloading).
+
+## How to Address Modules
+
+A module must always be addressed with the unique module name. The module name is case-sensitive.
+
+`myLib/MyModuleB.js`
+
+```js
+sap.ui.define(["myLib/MyModuleA"], function(MyModuleA){
+    ...
+});
+```
+
+For troubleshooting information with regard to addressing modules, see [What is wrong with the way I am addressing the modules?](troubleshooting-for-loading-modules-4363b3f.md#loio4363b3fe3561414ca1b030afc8cd30ce__section_moduleaddressing).
+
+### Migrating Access to Pseudo Modules
+
+Historically, types that are defined within a `library.js` could be required as if they were modules of their own \(i.e. as "pseudo modules"\). This behavior is deprecated, and the corresponding `library` module should be required instead. The example below showcases three scenarios how types might be used. You can find the corresponding module for each API, enum, and control in the API Reference, e.g. [`sap.m.ButtonType`](https://ui5.sap.com/#/api/sap.m.ButtonType) and [`sap.ui.model.FilterType`](https://ui5.sap.com/#/api/sap.ui.model.FilterType).
+
+-   enum types included in a `library.js`
+
+    e.g. you can use `sap.m.ButtonType` by requiring the `sap/m/library` module since it's documented as "Module: sap/m/library" in the API Reference. The type can then be accessed via the library's module export.
+
+-   enum types provided as a standalone module
+
+    e.g. you should require `sap/ui/model/FilterType` directly since it's documented as "Module: sap/ui/model/FilterType"
+
+-   Instances of DataType included in a `library.js`
+
+    e.g. you can use `sap.ui.core.CSSSize` by first requiring the `sap/ui/core/library` module as documented in the API Reference. The DataType itself can then be accessed via the static [`DataType.getType(...)`](https://ui5.sap.com/#/api/sap.ui.base.DataType/methods/sap.ui.base.DataType.getType) API as shown below.
+
+    > ### Note:  
+    > Accessing the DataType instance via the library's module export is also deprecated.
+
+
+**Example:**
+
+```js
+sap.ui.require([
+    "sap/m/library", // enum sap.m.ButtonType (Module: sap/m/library)
+    "sap/ui/model/FilterType", // enum sap.ui.model.FilterType (Module: sap/ui/model/FilterType)
+    "sap/ui/base/DataType", // DataType facade (Module: sap/ui/base/DataType)
+    "sap/ui/core/library" // includes the DataType "sap.ui.core.CSSSize" (Module: sap/ui/core/library)
+], (sapMLib, FilterType, DataType /*, sapUiCoreLib*/) => {
+    const { ButtonType } = sapMLib;
+
+    mySapMButton.setType(ButtonType.Emphasized);
+
+    myListBinding.filter(myFilter, FilterType.Application);
+
+    const oCSSSize = DataType.getType("sap.ui.core.CSSSize");
+    oCSSSize.isValid("20px") // true
+});
+```
+
+**Example for migrating several legacy aspects:**
+
+
+<table>
+<tr>
+<th valign="top" align="center">
+
+Legacy Code
+
+</th>
+<th valign="top" align="center">
+
+Best Practice
+
+</th>
+</tr>
+<tr>
+<td valign="top">
+
+```js
+sap.ui.define([
+  "sap/m/SortOrder", // Outdated pseudo module
+  "sap/ui/model/FilterType", // standalone module
+  "sap/ui/layout" // target use: SimpleForm
+], (SortOrder, FilterType, sapUiLayoutLib) => {
+  "use strict"
+  var SimpleForm = sapUiLayoutLib.form.SimpleForm; // access to Control via globals
+
+    // ...
+
+      // access to Control via globals
+      sap.m.MessageBox.show(/*...*/);
+
+    // ...
+
+});
+```
+
+</td>
+<td valign="top">
+
+```js
+sap.ui.define([
+  "sap/m/library", // "SortOrder" is contained in the sap/m/library.js module
+  "sap/ui/model/FilterType", // remains the same
+  "sap/ui/layout/form/SimpleForm" // imported as a module, no access to globals needed
+], (sapMLib, FilterType, SimpleForm) => {
+  "use strict";
+  const { SortOrder } = sapMLib;
+
+    // ...
+
+      // lazily require the sap/m/MessageBox on demand
+      sap.ui.require([
+        "sap/m/MessageBox"
+      ], (MessageBox) => {
+        MessageBox.show(/*...*/);
+      });
+
+    // ...
+
+});
+```
+
+</td>
+</tr>
+</table>
+
+## How to Structure a Project
+
+The entry point of an SAPUI5 application is often a module that is used to instantiate a SAPUI5 component. This central module is considered as single node of a graph and all dependent modules as well as their dependencies are nodes that must be connected by directed edges: the graph must fulfill the requirements of a directed acyclic graph \(DAG\).
+
+**Example**: All modules are evaluated in a clearly defined order. The evaluation starts with module D, then module C and module B, and ends with module A.
+
+For troubleshooting information with regard to the project structure, see [How can I remove project structures with cyclic dependencies?](troubleshooting-for-loading-modules-4363b3f.md#loio4363b3fe3561414ca1b030afc8cd30ce__section_cyclicdependencies).

package/resources/docs/1.136.7/0187ea5e2eff4166b0453b9dcc8fc64f.md

@@ -0,0 +1,164 @@
+# Component Metadata
+
+The component class provides specific metadata for components by extending the `ManagedObject` class. The `UIComponent` class provides additional metadata for the configuration of user interfaces or the navigation between views.
+
+> ### Note:  
+> With the introduction of the descriptor for applications, components, and libraries, we recommend to migrate the component metadata to the descriptor. The descriptor is inspired by W3C's Web Application Manifest and provides comprehensive information for applications, components and libraries. For more information, see [Manifest \(Descriptor for Applications, Components, and Libraries\)](manifest-descriptor-for-applications-components-and-libraries-be0cf40.md). The metadata property `manifest` must be set to `json` to indicate that the `manifest.json` file should be loaded and used:
+> 
+> ```js
+> // "Component" required from module "sap/ui/core/Component"
+> Component.extend("some.sample.Component", {
+>     "metadata": {
+>         "manifest": "json"
+>     }
+> });
+> ```
+> 
+> You can also define the descriptor inline by just providing an object. However, we do **not** recommend this because this would prevent that the descriptor can be analyzed by tools.
+
+The metadata defined in `Component.js` is common for components. The following parameters are available:
+
+-   `manifest`: Specifies if your component uses the descriptor
+
+-   `abstract`: Specifies if your component class is an abstract class that serves as a base for other components
+
+-   `version`: Version of your component; this parameter belongs to the design time metadata and is currently not used; it may be used in the future in the design time repository
+
+-   `properties`, `aggregations`, `associations`, and `events`: Define these for your component in the same way as for a control. For more information, see [Defining the Control Metadata](../09_Developing_Controls/defining-the-control-metadata-7b52540.md).
+
+-   `library`: Specifies the library to which your component belongs to
+
+
+The following properties are deprecated and no longer needed if you use the descriptor:
+
+-   `includes`: Array of strings containing the paths to CSS and JavaScript resources for your component; will be added to the header of the HTML page and loaded by the browser. The resources will be resolved relative to the location of `Component.js`.
+
+-   `dependencies`: Used to specify all external dependencies, such as libraries or components. Like the includes for resources that are added to the application's HTML, the dependencies are loaded by SAPUI5 core before the component is initialized. Everything that is referenced here can be used in your component code right from the start. Specify here external dependences such as libraries or components, that will be loaded by SAPUI5 core in the initialization phase of your Component and can be used after it.
+
+    -   `libs`: Path to the libraries that should be loaded by SAPUI5 core to be used in your component
+
+    -   `components`: Full path to the components that should be loaded by SAPUI5 core to be used in your component
+
+    -   `ui5version`: Minimum version of SAPUI5 that the component requires; it helps to be ensure that the features of SAPUI5 runtime used in this component are available. As SAPUI5 currently does not enforce the use of the correct version, it is only used for information purposes.
+
+
+-   `config`: Static configuration; specify the name-value pairs that you need in the component
+
+-   `customizing`: Extensions for components and views, see [Extending Apps](../08_Extending_SAPUI5_Applications/extending-apps-a264a9a.md)
+
+    -   `sap.ui.viewExtensions`: Used for providing custom view content in a specified extension point in the standard application
+
+    -   `sap.ui.viewModifications`: Used for overriding control properties in the standard application
+
+    -   `sap.ui.viewReplacements`: Used for replacing a standard view with a custom view
+
+    -   `sap.ui.controllerExtensions`: Used for extending a controller in a delivered standard application with a custom controller
+
+    -   `sap.ui.controllerReplacements`: Used for replacing a controller in a delivered standard application with a custom controller
+
+Example for metadata in `Component.js`:
+
+```js
+// "Component" required from module "sap/ui/core/Component"
+Component.extend("some.sample.Component", {
+    "metadata": {
+        "manifest": "json", // Specifies that your Component class uses the descriptor via the manifest.json file
+        "abstract": true, // Specifies if your Component class is an abstract one that serves as a base for your other components 
+        "library": "sap.ui.core", // Specifies the library the component belongs to
+        "version": "1.0", // Version of your Component
+        "properties": { // Defined for components in the same way as for a control or view
+            "config": "any"
+        }
+    }
+});
+```
+
+In addition to the common metadata for components, the `UIComponent` class provides the following metadata for UI components:
+
+-   `publicMethods`: Definition of public methods for your component
+
+-   `aggregations`: Defines aggregations for your component
+
+-   `interfaces`: Defines the interfaces implemented by your component.
+
+    We recommend to add the `sap.ui.core.IAsyncContentCreation` marker interface when defining a new component. Using this interface allows the component to be created fully asynchronously. This interface will implicitly set the component's `rootView` and router configuration to `async`. Nested views will also be handled asynchronously. Additionally, the error handling during the processing of views is stricter and will fail if a view definition contains errors, e.g. broken binding strings.
+
+
+The following properties are deprecated and no longer needed if you use the descriptor:
+
+-   `rootView`: Can be the view name as string or the view configuration object
+
+-   `routing`: Provides the default values for all views
+
+    -   `config`: Default values for routing that are applied, if no setting is specified by a route
+
+        -   `viewType`: View type of the view that is created, for example XML, JS or HTML
+
+        -   `viewPath`: Prefix that is preceding the view
+
+        -   `targetParent`: ID of the view in which the `targetControl` is searched
+
+        -   `targetControl`: ID of the control that contains the views
+
+        -   `targetAggregation`: Name of the aggregation of the `targetControl` that contains views
+
+        -   `clearTarget`: Boolean; if set to `true`, the aggregation should be cleared before adding the View to it
+
+
+    -   `routes`: Contains the configuration objects
+
+        -   `name`: Mandatory parameter used for listening or navigating to the route
+
+        -   `pattern`: String that is matched against the hash. The \{\} means this segment of the URL is passed to a handler with the value it contains
+
+        -   `view`: Name of the view that is created
+
+Example for UI component metadata:
+
+```js
+// "UIComponent" required from module "sap/ui/core/UIComponent"
+UIComponent.extend("some.sample.UIComponent", {
+    "metadata": {
+        "publicMethods": [ "render" ],
+        "aggregations": {
+            "rootControl": {
+                "type": "sap.ui.core.Control", multiple: false, visibility: "hidden"
+            }
+        }
+    }
+}),
+```
+
+## Properties Section in Component Metadata
+
+You can add a properties section to the metadata for all properties that can adopt different values during runtime. The getters and setters for these properties are generated automatically, but you can overwrite them if you require additional functionality. The following example contains two properties at the end of the metadata section.
+
+```js
+// "UIComponent" required from module "sap/ui/core/UIComponent"
+UIComponent.extend("samples.components.shell.Component", {
+    "metadata": {
+        "abstract": true,
+        "version": "1.0",
+...
+        "properties": {
+            "appTitle": {
+                "name":"appTitle",
+                "type":"string",
+                "defaultValue":"Default Value that will be replaced with something meaningful through the setter for this property"
+            },
+            "someOtherProp": {
+                "name":"myProperty",
+                "type":"string",
+                "defaultValue":"Some text"
+            }
+        }
+    }
+});
+```
+
+The getters and setters for these properties are generated automatically and can be overwritten if additional functionality is required.
+
+**Related Information**  
+
+
+[API Reference: `sap.ui.core.Component.MetadataOptions`](https://ui5.sap.com/#/api/sap.ui.core.Component.MetadataOptions)

package/resources/docs/1.136.7/032be2cb2e1d4115af20862673bedcdb.md

@@ -0,0 +1,12 @@
+# Test Starter
+
+The test starter is a concept intended to simplify the test setup for SAPUI5 applications and libraries by orchestrating your QUnit and OPA5 tests.
+
+## Goals
+
+Using the test starter concept in your project:
+
+-   reduces the boiler plate code needed to write a QUnit test;
+-   ensures the loading of the most commonly used testing frameworks \(for example, QUnit, Sinon.JS, qunit-reporter\);
+-   ensures these testing frameworks and your test modules are loaded completely asynchronously and comply with the [Content Security Policy](../05_Developing_Apps/content-security-policy-fe1a6db.md);
+-   allows moving the configuration of the testing frameworks out of the test code.