@sap-ux/fiori-mcp-server 0.0.1

package/dist/tools/functionalities/page/index.d.ts

@@ -0,0 +1,3 @@
+export { ADD_PAGE_FUNCTIONALITY, addPageHandlers } from './add-page';
+export { DELETE_PAGE_FUNCTIONALITY, deletePageHandlers } from './delete-page';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/functionalities/page/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePageHandlers = exports.DELETE_PAGE_FUNCTIONALITY = exports.addPageHandlers = exports.ADD_PAGE_FUNCTIONALITY = void 0;
+var add_page_1 = require("./add-page");
+Object.defineProperty(exports, "ADD_PAGE_FUNCTIONALITY", { enumerable: true, get: function () { return add_page_1.ADD_PAGE_FUNCTIONALITY; } });
+Object.defineProperty(exports, "addPageHandlers", { enumerable: true, get: function () { return add_page_1.addPageHandlers; } });
+var delete_page_1 = require("./delete-page");
+Object.defineProperty(exports, "DELETE_PAGE_FUNCTIONALITY", { enumerable: true, get: function () { return delete_page_1.DELETE_PAGE_FUNCTIONALITY; } });
+Object.defineProperty(exports, "deletePageHandlers", { enumerable: true, get: function () { return delete_page_1.deletePageHandlers; } });
+//# sourceMappingURL=index.js.map

package/dist/tools/functionalities/page/service.d.ts

@@ -0,0 +1,82 @@
+import { FioriAnnotationService } from '@sap-ux/fiori-annotation-api';
+import type { MetadataService } from '@sap-ux/odata-entity-model';
+import type { MetadataElement } from '@sap-ux/odata-annotation-core-types';
+import type { Project } from '@sap-ux/project-access';
+export type ServiceOptions = {
+    project: Project;
+    serviceName: string;
+    appName: string;
+};
+type MetadataNode = {
+    path: string;
+    name: string;
+    kind: string;
+    mdElement: MetadataElement;
+};
+export interface AllowedEntity {
+    entitySet: string;
+    entityType: string;
+    navigations: AllowedNavigation[];
+}
+export interface AllowedNavigation {
+    name: string;
+    fullyQualifiedName?: string;
+    entitySet: string;
+}
+/**
+ * Represents a service that manages Fiori metadata and annotations.
+ */
+export declare class Service {
+    private readonly options;
+    metadataService?: MetadataService;
+    annotationService?: FioriAnnotationService;
+    nodes: MetadataNode[];
+    nodesMap: Map<string, MetadataNode>;
+    private namespace;
+    /**
+     * Creates a new instance of the Service class.
+     *
+     * @param options - Configuration options for the service,.
+     */
+    constructor(options: ServiceOptions);
+    /**
+     * Loads and initializes metadata and annotation services.
+     *
+     * @param refresh - Whether to force a reload of the metadata.
+     * @returns A promise that resolves when metadata is loaded.
+     */
+    private loadMetadata;
+    /**
+     * Visits a metadata element and registers it as a node within the service.
+     *
+     * @param mdElement - The metadata element to process and register.
+     */
+    visitMdElement(mdElement: MetadataElement): void;
+    /**
+     * Retrieves the namespace for the current instance.
+     *
+     * @returns {Promise<string>} A promise that resolves to the namespace string.
+     */
+    getNamespace(): Promise<string>;
+    /**
+     * Retrieves a list of allowed entities from the loaded metadata.
+     * Each entity includes its entity set name, entity type, and navigable properties
+     * that are collections (i.e., to-many relationships).
+     *
+     * @param refresh Refresh metadata by avoiding cached values.
+     * @returns A promise that resolves to an array of allowed entities with their navigations.
+     */
+    getAllowedEntities(refresh?: boolean): Promise<AllowedEntity[]>;
+    /**
+     * Retrieves the allowed navigation properties for a given entity set or entity type.
+     * These are filtered from the allowed entities' navigation collections.
+     *
+     * @param entitySet Optional entity set name to match.
+     * @param entityType Optional entity type name to match.
+     * @param refresh Refresh metadata by avoiding cached values.
+     * @returns A promise that resolves to an array of allowed navigations.
+     */
+    getAllowedNavigations(entitySet?: string, entityType?: string, refresh?: boolean): Promise<AllowedNavigation[]>;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/tools/functionalities/page/service.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const fiori_annotation_api_1 = require("@sap-ux/fiori-annotation-api");
+const project_access_1 = require("@sap-ux/project-access");
+const annotation_converter_1 = require("@sap-ux/annotation-converter");
+/**
+ * Represents a service that manages Fiori metadata and annotations.
+ */
+class Service {
+    options;
+    metadataService;
+    annotationService;
+    nodes = [];
+    nodesMap = new Map();
+    namespace = '';
+    /**
+     * Creates a new instance of the Service class.
+     *
+     * @param options - Configuration options for the service,.
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Loads and initializes metadata and annotation services.
+     *
+     * @param refresh - Whether to force a reload of the metadata.
+     * @returns A promise that resolves when metadata is loaded.
+     */
+    async loadMetadata(refresh = false) {
+        if (!refresh && this.metadataService) {
+            return;
+        }
+        const { project, serviceName, appName } = this.options;
+        const projectNew = await (0, project_access_1.getProject)(project.root);
+        this.annotationService = await fiori_annotation_api_1.FioriAnnotationService.createService(projectNew, serviceName, appName);
+        await this.annotationService.sync();
+        this.metadataService = this.annotationService.getMetadataService();
+        this.namespace = [...this.metadataService.getNamespaces()][0];
+        this.metadataService.visitMetadataElements(this.visitMdElement.bind(this));
+    }
+    /**
+     * Visits a metadata element and registers it as a node within the service.
+     *
+     * @param mdElement - The metadata element to process and register.
+     */
+    visitMdElement(mdElement) {
+        const { path, name } = mdElement;
+        const kind = this.metadataService?.getEdmTargetKinds(path)[0] || '';
+        const metadataNode = { path, name, mdElement, kind };
+        this.nodes?.push(metadataNode);
+        this.nodesMap.set(path, metadataNode);
+    }
+    /**
+     * Retrieves the namespace for the current instance.
+     *
+     * @returns {Promise<string>} A promise that resolves to the namespace string.
+     */
+    async getNamespace() {
+        await this.loadMetadata();
+        return this.namespace;
+    }
+    /**
+     * Retrieves a list of allowed entities from the loaded metadata.
+     * Each entity includes its entity set name, entity type, and navigable properties
+     * that are collections (i.e., to-many relationships).
+     *
+     * @param refresh Refresh metadata by avoiding cached values.
+     * @returns A promise that resolves to an array of allowed entities with their navigations.
+     */
+    async getAllowedEntities(refresh = false) {
+        await this.loadMetadata(refresh);
+        if (!this.annotationService) {
+            return [];
+        }
+        const allowedEntities = [];
+        const rawMetadata = this.annotationService.getSchema();
+        const metadata = (0, annotation_converter_1.convert)(rawMetadata);
+        for (const entitySet of metadata.entitySets) {
+            allowedEntities.push({
+                entitySet: entitySet.name,
+                entityType: entitySet.entityType.name,
+                navigations: entitySet.entityType.navigationProperties
+                    .filter((navigationProperty) => navigationProperty.isCollection)
+                    .map((navigationProperty) => {
+                    const entityType = navigationProperty.targetType;
+                    const entitySet = metadata.entitySets.find((entitySet) => entitySet.entityTypeName === entityType.name);
+                    return {
+                        name: navigationProperty.name,
+                        fullyQualifiedName: navigationProperty.fullyQualifiedName,
+                        entitySet: entitySet?.name ?? entityType.name
+                    };
+                })
+            });
+        }
+        return allowedEntities;
+    }
+    /**
+     * Retrieves the allowed navigation properties for a given entity set or entity type.
+     * These are filtered from the allowed entities' navigation collections.
+     *
+     * @param entitySet Optional entity set name to match.
+     * @param entityType Optional entity type name to match.
+     * @param refresh Refresh metadata by avoiding cached values.
+     * @returns A promise that resolves to an array of allowed navigations.
+     */
+    async getAllowedNavigations(entitySet, entityType, refresh = false) {
+        const allowedEntities = this.getAllowedEntities(refresh);
+        return ((await allowedEntities).find((allowedEntity) => allowedEntity.entitySet === entitySet || allowedEntity.entityType === entityType)?.navigations ?? []);
+    }
+}
+exports.Service = Service;
+//# sourceMappingURL=service.js.map

package/dist/tools/functionalities/page/serviceStore.d.ts

@@ -0,0 +1,17 @@
+import type { ServiceOptions } from './service';
+import { Service } from './service';
+/**
+ * Get service from service store (cache).
+ *
+ * @param options Service options.
+ * @returns Resolved service from service store (cache).
+ */
+export declare function getService(options: ServiceOptions): Promise<Service>;
+/**
+ * Removes a service from the `serviceStore`.
+ *
+ * @param options - The configuration object containing details about the service.
+ * @returns `true` if the service was removed successfully.
+ */
+export declare function removeService(options: ServiceOptions): boolean;
+//# sourceMappingURL=serviceStore.d.ts.map

package/dist/tools/functionalities/page/serviceStore.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getService = getService;
+exports.removeService = removeService;
+const service_1 = require("./service");
+const serviceStore = new Map();
+/**
+ * Get service from service store (cache).
+ *
+ * @param options Service options.
+ * @returns Resolved service from service store (cache).
+ */
+async function getService(options) {
+    const key = options.serviceName;
+    if (!serviceStore.has(key)) {
+        serviceStore.set(key, new service_1.Service(options));
+    }
+    const service = serviceStore.get(key);
+    if (!service) {
+        throw new Error(`No service: '${key}'`);
+    }
+    return service;
+}
+/**
+ * Removes a service from the `serviceStore`.
+ *
+ * @param options - The configuration object containing details about the service.
+ * @returns `true` if the service was removed successfully.
+ */
+function removeService(options) {
+    const key = options.serviceName;
+    return serviceStore.delete(key);
+}
+//# sourceMappingURL=serviceStore.js.map

package/dist/tools/functionalities/page/types.d.ts

@@ -0,0 +1,42 @@
+import type { PageTypeV4 } from '@sap/ux-specification/dist/types/src';
+export interface NewBasePage {
+    parent?: string;
+    pageType: PageTypeV4;
+    navigation?: string;
+    entitySet?: string;
+    newEntity?: boolean;
+}
+export interface NewObjectPage extends NewBasePage {
+    pageType: PageTypeV4.ObjectPage;
+}
+export interface NewListReport extends NewBasePage {
+    pageType: PageTypeV4.ListReport;
+}
+export interface NewCustomPage extends NewBasePage {
+    pageType: PageTypeV4.CustomPage;
+    viewName: string;
+}
+export type NewPage = NewObjectPage | NewListReport | NewCustomPage;
+export interface PageDef {
+    pageId: string;
+    pageType: string;
+    entitySet: string;
+    contextPath?: string;
+    routePattern?: string;
+    viewName?: string;
+}
+export interface AllowedNavigation {
+    name: string;
+    fullyQualifiedName?: string;
+    entitySet: string;
+}
+export interface AllowedNavigationOptions extends AllowedNavigation {
+    isNavigation?: boolean;
+}
+export declare enum MissingNavigationReason {
+    NoAnyNavigationsForParent = 1,
+    NotFoundNavigationForParent = 2,
+    NoEntityProvided = 3,
+    NotFoundEntity = 4
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/functionalities/page/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingNavigationReason = void 0;
+var MissingNavigationReason;
+(function (MissingNavigationReason) {
+    MissingNavigationReason[MissingNavigationReason["NoAnyNavigationsForParent"] = 1] = "NoAnyNavigationsForParent";
+    MissingNavigationReason[MissingNavigationReason["NotFoundNavigationForParent"] = 2] = "NotFoundNavigationForParent";
+    MissingNavigationReason[MissingNavigationReason["NoEntityProvided"] = 3] = "NoEntityProvided";
+    MissingNavigationReason[MissingNavigationReason["NotFoundEntity"] = 4] = "NotFoundEntity";
+})(MissingNavigationReason || (exports.MissingNavigationReason = MissingNavigationReason = {}));
+//# sourceMappingURL=types.js.map

package/dist/tools/functionalities/page/utils.d.ts

@@ -0,0 +1,12 @@
+import type { PageDef } from './types';
+/**
+ * Generates the id for a new page.
+ *
+ * @param page - page attributes.
+ * @param parentPage - parent page.
+ * @param pages - Object with existing pages.
+ * @param navigationProperty - navigation property (optional).
+ * @returns Generated page id.
+ */
+export declare function generatePageId(page: PageDef, parentPage: string | undefined, pages: PageDef[], navigationProperty?: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/tools/functionalities/page/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePageId = generatePageId;
+const src_1 = require("@sap/ux-specification/dist/types/src");
+const newPagePrefixForType = new Map([
+    [src_1.PageTypeV4.ListReport, 'List'],
+    [src_1.PageTypeV4.ObjectPage, src_1.PageTypeV4.ObjectPage],
+    [src_1.PageTypeV4.CustomPage, 'Page'],
+    [src_1.PageTypeV4.FPMCustomPage, 'Page'],
+    [src_1.PageTypeV4.AnalyticalListPage, 'ALP']
+]);
+/**
+ * Generates the id for a new V4 page.
+ *
+ * @param page - page attributes.
+ * @param parentPage - parent page; to check if it is a root page.
+ * @param navigationProperty - Navigation property (optional).
+ * @returns parts = an array of strings that shall be joined to form the page ID.
+ */
+function generatePageIdV4(page, parentPage, navigationProperty) {
+    let name = '';
+    let parts = [];
+    // Populate with page entity or name
+    if (page.pageType === src_1.PageTypeV4.CustomPage || page.pageType === src_1.PageTypeV4.FPMCustomPage) {
+        const viewId = page.viewName ?? '';
+        const names = viewId.split('.');
+        name = names[names.length - 1];
+    }
+    else {
+        name = page.contextPath ? page.contextPath.slice(1).replace(/\//g, '_') : page.entitySet;
+    }
+    parts = [name];
+    if (parentPage &&
+        navigationProperty &&
+        (!page.contextPath || page.contextPath.indexOf(navigationProperty) === -1)) {
+        parts.push(navigationProperty);
+    }
+    // Append page type to last part of page id - it places page type at the end of id without separator
+    parts[parts.length - 1] += newPagePrefixForType.get(page.pageType);
+    return parts;
+}
+/**
+ * Generates the id for a new page.
+ *
+ * @param page - page attributes.
+ * @param parentPage - parent page.
+ * @param pages - Object with existing pages.
+ * @param navigationProperty - navigation property (optional).
+ * @returns Generated page id.
+ */
+function generatePageId(page, parentPage, pages, navigationProperty) {
+    // Page generation for V4 page
+    const parts = generatePageIdV4(page, parentPage, navigationProperty);
+    let pageId = parts.join('_');
+    const existingPageIds = pages.map((existingPage) => existingPage.pageId);
+    let idx = 0;
+    while (existingPageIds.indexOf(pageId) > -1) {
+        pageId += idx.toString();
+        idx++;
+    }
+    return pageId;
+}
+//# sourceMappingURL=utils.js.map

package/dist/tools/get-functionality-details.d.ts

@@ -0,0 +1,24 @@
+import type { GetFunctionalityDetailsInput, GetFunctionalityDetailsOutput } from '../types';
+import type { PropertyPath } from '../page-editor-api';
+/**
+ * Retrieves functionality details based on the provided input parameters.
+ *
+ * @param params - The input parameters for getting functionality details.
+ * @param params.appPath - The path to the application.
+ * @param params.functionalityId - The ID of the functionality to retrieve details for.
+ * @returns A promise that resolves to the functionality details output.
+ * @throws Error if appPath or functionalityId is not provided.
+ */
+export declare function getFunctionalityDetails(params: GetFunctionalityDetailsInput): Promise<GetFunctionalityDetailsOutput>;
+/**
+ * Resolves a functionality ID into a page name and property path.
+ *
+ * @param functionalityId - The ID of the functionality to resolve, either as a string or an array of strings.
+ * @returns An object containing the resolved page name (if applicable) and property path.
+ * @throws Error if the functionalityId parameter has an invalid format.
+ */
+export declare function resolveFunctionality(functionalityId: string | string[]): {
+    pageName?: string;
+    propertyPath: PropertyPath;
+};
+//# sourceMappingURL=get-functionality-details.d.ts.map

package/dist/tools/get-functionality-details.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionalityDetails = getFunctionalityDetails;
+exports.resolveFunctionality = resolveFunctionality;
+const page_editor_api_1 = require("../page-editor-api");
+const functionalities_1 = require("./functionalities");
+const utils_1 = require("./utils");
+/**
+ * Retrieves functionality details based on the provided input parameters.
+ *
+ * @param params - The input parameters for getting functionality details.
+ * @param params.appPath - The path to the application.
+ * @param params.functionalityId - The ID of the functionality to retrieve details for.
+ * @returns A promise that resolves to the functionality details output.
+ * @throws Error if appPath or functionalityId is not provided.
+ */
+async function getFunctionalityDetails(params) {
+    const { appPath, functionalityId } = params;
+    if (!appPath) {
+        throw new Error('appPath parameter is required');
+    }
+    if (!functionalityId) {
+        throw new Error('functionalityId parameter is required');
+    }
+    const externalFunctionality = typeof functionalityId === 'string' ? functionalities_1.FUNCTIONALITIES_HANDLERS.get(functionalityId) : undefined;
+    if (externalFunctionality) {
+        return externalFunctionality.getFunctionalityDetails(params);
+    }
+    const { pageName, propertyPath } = resolveFunctionality(functionalityId);
+    const page = await getDetails(appPath, pageName);
+    const details = page ? getPropertyDetails(page, propertyPath) : undefined;
+    if (!details) {
+        throw new Error('functionalityId was not resolved');
+    }
+    if (pageName) {
+        details.pageName = pageName;
+    }
+    return details;
+}
+/**
+ * Converts TreeNodeProperty objects to Parameter objects.
+ *
+ * @param properties - An array of TreeNodeProperty objects to convert.
+ * @returns An array of Parameter objects.
+ */
+function getParameters(properties) {
+    const parameters = [];
+    for (const property of properties) {
+        const parameter = {
+            id: property.name,
+            name: property.displayName,
+            description: property.description,
+            type: property.type,
+            currentValue: property.value
+        };
+        if (property.options) {
+            parameter.options = property.options.map((option) => option.key);
+        }
+        if (property.properties) {
+            parameter.parameters = getParameters(property.properties);
+        }
+        parameters.push(parameter);
+    }
+    return parameters;
+}
+/**
+ * Retrieves property details from a page tree node based on the provided property path.
+ *
+ * @param page - The root TreeNode of the page.
+ * @param propertyPath - The path to the desired property.
+ * @returns The functionality details output for the specified property, or undefined if not found.
+ */
+function getPropertyDetails(page, propertyPath) {
+    const { property, node } = (0, page_editor_api_1.findByPath)([page], propertyPath) ?? {};
+    let details;
+    if (property) {
+        // Property was found by path
+        const parameters = getParameters([property]);
+        details = {
+            functionalityId: 'change-property',
+            name: 'Change property',
+            // There is issue in cline by applying values with undefined - throws error "Invalid JSON argument".
+            // As workaround - I am using approach with null as currently there is no use case where null is real value.
+            description: `Change a property. To reset, remove, or restore it to its default value, set the value to null. If the property's description does not specify how to disable the related feature, setting it to null is typically the appropriate way to disable or clear it.`,
+            parameters
+        };
+    }
+    else if (node?.path.length) {
+        // Node was found by path - list node properties
+        let parameters = [];
+        for (const property of node.properties) {
+            parameters = parameters.concat(getParameters([property]));
+        }
+        details = {
+            functionalityId: 'change-property',
+            name: 'Change property',
+            // There is issue in cline by applying values with undefined - throws error "Invalid JSON argument".
+            // As workaround - I am using approach with null as currently there is no use case where null is real value.
+            description: `Change a property. To reset, remove, or restore it to its default value, set the value to null. If the property's description does not specify how to disable the related feature, setting it to null is typically the appropriate way to disable or clear it.`,
+            parameters
+        };
+    }
+    return details;
+}
+/**
+ * Retrieves the page tree for a given application and page.
+ *
+ * @param appPath - The path to the application.
+ * @param pageName - Optional. The name of the page to retrieve details for.
+ * @returns A promise that resolves to the page TreeNode, or undefined if not found.
+ */
+async function getDetails(appPath, pageName) {
+    const project = await (0, utils_1.resolveApplication)(appPath);
+    if (project?.applicationAccess) {
+        const pageEditorApi = new page_editor_api_1.PageEditorApi(project.applicationAccess, pageName);
+        return pageEditorApi.getPageTree();
+    }
+}
+/**
+ * Resolves a functionality ID into a page name and property path.
+ *
+ * @param functionalityId - The ID of the functionality to resolve, either as a string or an array of strings.
+ * @returns An object containing the resolved page name (if applicable) and property path.
+ * @throws Error if the functionalityId parameter has an invalid format.
+ */
+function resolveFunctionality(functionalityId) {
+    let propertyPath;
+    try {
+        propertyPath = typeof functionalityId === 'string' ? JSON.parse(functionalityId) : [...functionalityId];
+    }
+    catch (e) {
+        // The functionalityId is expected to be either a string array (e.g. "['Id1', 'Id2']") or an array of strings (e.g. ['Id1', 'Id2']).
+        throw new Error(`Invalid format of functionalityId parameter, error: ${e}`);
+    }
+    let pageName;
+    if (propertyPath[0] !== 'settings') {
+        // Currently all application paths starts with settings and it is simple to detect pagename from path
+        pageName = propertyPath.shift()?.toString();
+    }
+    return { pageName, propertyPath };
+}
+//# sourceMappingURL=get-functionality-details.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export { listFioriApps } from './list-fiori-apps';
+export { listFunctionalities } from './list-functionalities';
+export { getFunctionalityDetails } from './get-functionality-details';
+export { executeFunctionality } from './execute-functionality';
+export declare const tools: Tool[];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = exports.executeFunctionality = exports.getFunctionalityDetails = exports.listFunctionalities = exports.listFioriApps = void 0;
+const output_schema_1 = require("./output-schema");
+const input_schema_1 = require("./input-schema");
+var list_fiori_apps_1 = require("./list-fiori-apps");
+Object.defineProperty(exports, "listFioriApps", { enumerable: true, get: function () { return list_fiori_apps_1.listFioriApps; } });
+var list_functionalities_1 = require("./list-functionalities");
+Object.defineProperty(exports, "listFunctionalities", { enumerable: true, get: function () { return list_functionalities_1.listFunctionalities; } });
+var get_functionality_details_1 = require("./get-functionality-details");
+Object.defineProperty(exports, "getFunctionalityDetails", { enumerable: true, get: function () { return get_functionality_details_1.getFunctionalityDetails; } });
+var execute_functionality_1 = require("./execute-functionality");
+Object.defineProperty(exports, "executeFunctionality", { enumerable: true, get: function () { return execute_functionality_1.executeFunctionality; } });
+exports.tools = [
+    {
+        name: 'list-fiori-apps',
+        description: `Scans a specified directory to find existing SAP Fiori applications that can be modified.
+                    This is an optional, preliminary tool.
+                    **Use this first ONLY if the target application's name or path is not already known.**
+                    The output can be used to ask the user for clarification before starting the main 3-step workflow.`,
+        inputSchema: input_schema_1.listFioriAppsInputSchema,
+        outputSchema: output_schema_1.listFioriAppsOutputSchema
+    },
+    {
+        name: 'list-functionality',
+        description: `**(Step 1 of 3)**
+                    Gets the complete and exclusive list of supported functionalities to create a new or modify an existing SAP Fiori application.
+                    This is the **first mandatory step** to begin the workflow and requires a valid absolute path to a SAP Fiori application as input.
+                    You MUST use a functionalityId from this tool's output to request details to the functionality in 'get-functionality-details' (Step 2).
+                    You MUST not use a functionalityId as name of a tool.
+                    Do not guess, assume, or use any functionality not present in this list, as it is invalid and will cause the operation to fail.
+                    **Note: If the target application is not known, use the list-fiori-apps tool first to identify it.**`,
+        inputSchema: input_schema_1.listFunctionalityInputSchema,
+        outputSchema: output_schema_1.listFunctionalityOutputSchema
+    },
+    {
+        name: 'get-functionality-details',
+        description: `**(Step 2 of 3)**
+                    Gets the required parameters and detailed information for a specific functionality to create a new or modify an existing SAP Fiori application.
+                    You MUST provide a functionalityId obtained from 'list-functionality' (Step 1).
+                    The output of this tool is required for the final step 'execute-functionality' (Step 3).`,
+        inputSchema: input_schema_1.getFunctionalityDetailsInputSchema,
+        outputSchema: output_schema_1.getFunctionalityDetailsOutputSchema
+    },
+    {
+        name: 'execute-functionality',
+        description: `**(Step 3 of 3)**
+                    Executes a specific functionality to create a new or modify an existing SAP Fiori application with provided parameters.
+                    This is the **final step** of the workflow and performs the actual creation or modification.
+                    You MUST provide the exact parameter information obtained from get-functionality-details (Step 2).`,
+        inputSchema: input_schema_1.executeFunctionalityInputSchema,
+        outputSchema: output_schema_1.executeFunctionalityOutputSchema
+    }
+];
+//# sourceMappingURL=index.js.map

package/dist/tools/input-schema/execute-functionality.json

@@ -0,0 +1,28 @@
+{
+    "type": "object",
+    "properties": {
+        "appPath": {
+            "type": "string",
+            "description": "Path to the Fiori application. Path should be an absolute path."
+        },
+        "functionalityId": {
+            "anyOf": [
+                {
+                    "type": "array",
+                    "items": {
+                        "type": ["string", "number"]
+                    }
+                },
+                {
+                    "type": "string"
+                }
+            ],
+            "description": "The ID of the functionality to execute"
+        },
+        "parameters": {
+            "type": "object",
+            "description": "Parameters for the functionality execution"
+        }
+    },
+    "required": ["functionalityId", "appPath", "parameters"]
+}