@arc-mcp/adt-ls - v0.6.1
    Preparing search index...

    Interface AdtLsClient

    The unified adt-ls client returned by createAdtLs. One coherent surface over both adt-ls channels (LSP + adt-ls's own MCP) — the channel split is hidden. Always call dispose() when finished.

    interface AdtLsClient {
        lifecycle: {
            activate(
                args: ObjectRef & { forceActivation?: boolean },
            ): Promise<ActivateResult>;
            create(
                args: {
                    additionalFields?: Record<string, unknown>;
                    description: string;
                    name: string;
                    objectType: string;
                    packageName: string;
                    transportRequestNumber?: string;
                },
            ): Promise<CreateResult>;
            delete(args: ObjectRef): Promise<void>;
            generate(
                args: {
                    content: string;
                    generatorId: string;
                    packageName: string;
                    referencedObjectName?: string;
                    referencedObjectType?: string;
                    transportRequestNumber?: string;
                },
            ): Promise<unknown>;
            getCreationForm(
                objectType: string,
                opts?: { name?: string },
            ): Promise<{ fields: CreationField[]; objectType: string }>;
            getGeneratorSchema(
                generatorId: string,
                opts?: {
                    packageName?: string;
                    referencedObjectName?: string;
                    referencedObjectType?: string;
                },
            ): Promise<unknown>;
            getObjectTypeDetails(
                objectType: string,
                opts?: { name?: string },
            ): Promise<unknown>;
            listCreatableObjects(): Promise<unknown>;
            listGenerators(): Promise<unknown>;
            resolveAffUri(ref: ObjectRef): Promise<string>;
            runUnitTests(args: ObjectRef): Promise<unknown>;
            update(
                args: ObjectRef & { include?: string; source: string },
            ): Promise<void>;
            validate(
                args: {
                    additionalFields?: Record<string, unknown>;
                    description: string;
                    name: string;
                    objectType: string;
                    packageName: string;
                },
            ): Promise<unknown>;
        };
        navigation: Navigation;
        quality: Quality;
        raw: {
            lsp<T = unknown>(method: string, params?: unknown): Promise<T>;
            tool(name: string, args?: Record<string, unknown>): Promise<unknown>;
        };
        repository: {
            delete(uri: string): Promise<unknown>;
            getLsUri(adtUri: string): Promise<string>;
            getUsers(): Promise<UserRef[]>;
            listInactive(): Promise<unknown[]>;
            readFile(uri: string): Promise<string>;
            search(
                pattern: string,
                opts?: { cold?: boolean; maxResults?: number; types?: string[] },
            ): Promise<QuickSearchResult>;
            writeFile(uri: string, content: string): Promise<unknown>;
        };
        services: Services;
        source: { read(args: ObjectRef & { include?: string }): Promise<string> };
        transport: {
            assign(
                args: ObjectRef & { transport: string },
            ): Promise<
                {
                    assigned: boolean;
                    lockedIn: string[];
                    object: string;
                    objectType: string;
                    transport: string;
                },
            >;
            check(
                args: ObjectRef & {
                    operation?: "CREATE" | "MODIFY" | "DELETE";
                    recordChanges?: boolean;
                    transportLayer?: string;
                },
            ): Promise<unknown>;
            create(
                args: {
                    developmentPackage: string;
                    isCreation: boolean;
                    objectName: string;
                    objectType: string;
                    transportDescription: string;
                },
            ): Promise<unknown>;
            find(
                args: {
                    developmentPackage: string;
                    isCreation: boolean;
                    objectName: string;
                    objectType: string;
                },
            ): Promise<unknown>;
            getDiff(
                transportNumber: string,
                opts?: { cursor?: string; pageSize?: number },
            ): Promise<TransportDiffPage>;
            getLockStatus(
                args: ObjectRef,
            ): Promise<{ lockId: string | null; lockingSupported: boolean }>;
            list(opts?: { limit?: number; query?: string }): Promise<unknown>;
        };
        capabilities(): Promise<AdtLsCapabilities>;
        dispose(): Promise<void>;
        health(): HealthInfo;
        listDestinations(): Promise<unknown>;
        reconnect(): Promise<boolean>;
    }
    Index

    Properties

    lifecycle navigation quality raw repository services source transport

    Methods

    capabilities dispose health listDestinations reconnect

    Properties

    lifecycle: {
        activate(
            args: ObjectRef & { forceActivation?: boolean },
        ): Promise<ActivateResult>;
        create(
            args: {
                additionalFields?: Record<string, unknown>;
                description: string;
                name: string;
                objectType: string;
                packageName: string;
                transportRequestNumber?: string;
            },
        ): Promise<CreateResult>;
        delete(args: ObjectRef): Promise<void>;
        generate(
            args: {
                content: string;
                generatorId: string;
                packageName: string;
                referencedObjectName?: string;
                referencedObjectType?: string;
                transportRequestNumber?: string;
            },
        ): Promise<unknown>;
        getCreationForm(
            objectType: string,
            opts?: { name?: string },
        ): Promise<{ fields: CreationField[]; objectType: string }>;
        getGeneratorSchema(
            generatorId: string,
            opts?: {
                packageName?: string;
                referencedObjectName?: string;
                referencedObjectType?: string;
            },
        ): Promise<unknown>;
        getObjectTypeDetails(
            objectType: string,
            opts?: { name?: string },
        ): Promise<unknown>;
        listCreatableObjects(): Promise<unknown>;
        listGenerators(): Promise<unknown>;
        resolveAffUri(ref: ObjectRef): Promise<string>;
        runUnitTests(args: ObjectRef): Promise<unknown>;
        update(
            args: ObjectRef & { include?: string; source: string },
        ): Promise<void>;
        validate(
            args: {
                additionalFields?: Record<string, unknown>;
                description: string;
                name: string;
                objectType: string;
                packageName: string;
            },
        ): Promise<unknown>;
    }

    The authoring lifecycle for object types served by the installed runtime/backend.

    Type Declaration

    • activate: function
      • activate(
            args: ObjectRef & { forceActivation?: boolean },
        ): Promise<ActivateResult>

        Activate via native activation/activate (per-phase flags + refresh URIs; optional forceActivation). success:false with structured diagnostics on failure.

        Parameters

        • args: ObjectRef & { forceActivation?: boolean }

        Returns Promise<ActivateResult>

    • create: function
      • create(
            args: {
                additionalFields?: Record<string, unknown>;
                description: string;
                name: string;
                objectType: string;
                packageName: string;
                transportRequestNumber?: string;
            },
        ): Promise<CreateResult>

        Create an object. transportRequestNumber is '' for $TMP/local packages.

        Parameters

        • args: {
              additionalFields?: Record<string, unknown>;
              description: string;
              name: string;
              objectType: string;
              packageName: string;
              transportRequestNumber?: string;
          }
          • OptionaladditionalFields?: Record<string, unknown>

            Type-specific creation fields from getCreationForm; explicit name/package/description win.

          • description: string
          • name: string
          • objectType: string
          • packageName: string
          • OptionaltransportRequestNumber?: string

        Returns Promise<CreateResult>

    • delete: function
      • delete(args: ObjectRef): Promise<void>

        Delete the object (targets its .json metadata).

        Parameters

        Returns Promise<void>

    • generate: function
      • generate(
            args: {
                content: string;
                generatorId: string;
                packageName: string;
                referencedObjectName?: string;
                referencedObjectType?: string;
                transportRequestNumber?: string;
            },
        ): Promise<unknown>

        Run a RAP generator → a full object set (table/CDS/BDEF/SRVD/SRVB).

        Parameters

        • args: {
              content: string;
              generatorId: string;
              packageName: string;
              referencedObjectName?: string;
              referencedObjectType?: string;
              transportRequestNumber?: string;
          }

        Returns Promise<unknown>

    • getCreationForm: function
      • getCreationForm(
            objectType: string,
            opts?: { name?: string },
        ): Promise<{ fields: CreationField[]; objectType: string }>

        Full creation form contract — each field's value-help target types, name regex, label, required — parsed from the native UI model (richer than getObjectTypeDetails).

        Parameters

        • objectType: string
        • Optionalopts: { name?: string }

        Returns Promise<{ fields: CreationField[]; objectType: string }>

    • getGeneratorSchema: function
      • getGeneratorSchema(
            generatorId: string,
            opts?: {
                packageName?: string;
                referencedObjectName?: string;
                referencedObjectType?: string;
            },
        ): Promise<unknown>

        The JSON input schema a generator's content must satisfy.

        Parameters

        • generatorId: string
        • Optionalopts: {
              packageName?: string;
              referencedObjectName?: string;
              referencedObjectType?: string;
          }

        Returns Promise<unknown>

    • getObjectTypeDetails: function
      • getObjectTypeDetails(
            objectType: string,
            opts?: { name?: string },
        ): Promise<unknown>

        Creation details (flat MCP field list) for one object type, e.g. "CLAS/OC".

        Parameters

        • objectType: string
        • Optionalopts: { name?: string }

        Returns Promise<unknown>

    • listCreatableObjects: function
      • listCreatableObjects(): Promise<unknown>

        List the object types creatable on this system (ABAP-Cloud / RAP catalog).

        Returns Promise<unknown>

    • listGenerators: function
      • listGenerators(): Promise<unknown>

        List the available RAP generators (feed an id to generate / getGeneratorSchema).

        Returns Promise<unknown>

    • resolveAffUri: function
      • resolveAffUri(ref: ObjectRef): Promise<string>

        Resolve {name, objectType} → repotree AFF URI (search → getLsUri).

        Parameters

        Returns Promise<string>

    • runUnitTests: function
    • update: function
      • update(args: ObjectRef & { include?: string; source: string }): Promise<void>

        Update an object's source (optionally a specific include).

        Parameters

        • args: ObjectRef & { include?: string; source: string }

        Returns Promise<void>

    • validate: function
      • validate(
            args: {
                additionalFields?: Record<string, unknown>;
                description: string;
                name: string;
                objectType: string;
                packageName: string;
            },
        ): Promise<unknown>

        Validate creation input before create (read-only verdict).

        Parameters

        • args: {
              additionalFields?: Record<string, unknown>;
              description: string;
              name: string;
              objectType: string;
              packageName: string;
          }

        Returns Promise<unknown>

    navigation: Navigation

    LSP code-intelligence (symbols, definition, references, type-hierarchy, hover, completion, syntax check).

    quality: Quality

    Quality: ATC static analysis + ABAP Unit code coverage.

    raw: {
        lsp<T = unknown>(method: string, params?: unknown): Promise<T>;
        tool(name: string, args?: Record<string, unknown>): Promise<unknown>;
    }

    Escape hatches for the long tail (ADR-0002).

    Type Declaration

    • lsp: function
      • lsp<T = unknown>(method: string, params?: unknown): Promise<T>

        Raw LSP / adtLs/* request.

        Type Parameters

        • T = unknown

        Parameters

        • method: string
        • Optionalparams: unknown

        Returns Promise<T>

    • tool: function
      • tool(name: string, args?: Record<string, unknown>): Promise<unknown>

        Raw call to a tool on adt-ls's own MCP server (e.g. a backend-dynamic tool).

        Parameters

        • name: string
        • Optionalargs: Record<string, unknown>

        Returns Promise<unknown>

    repository: {
        delete(uri: string): Promise<unknown>;
        getLsUri(adtUri: string): Promise<string>;
        getUsers(): Promise<UserRef[]>;
        listInactive(): Promise<unknown[]>;
        readFile(uri: string): Promise<string>;
        search(
            pattern: string,
            opts?: { cold?: boolean; maxResults?: number; types?: string[] },
        ): Promise<QuickSearchResult>;
        writeFile(uri: string, content: string): Promise<unknown>;
    }

    Repository queries + file operations + the name→URI resolver.

    Type Declaration

    • delete: function
      • delete(uri: string): Promise<unknown>

        Delete by AFF URI (use the .json metadata URI for objects).

        Parameters

        • uri: string

        Returns Promise<unknown>

    • getLsUri: function
      • getLsUri(adtUri: string): Promise<string>

        Resolve an ADT object path to the canonical repotree AFF URI used by file ops.

        Parameters

        • adtUri: string

        Returns Promise<string>

    • getUsers: function
      • getUsers(): Promise<UserRef[]>

        List user master records visible to the logged-on user.

        Returns Promise<UserRef[]>

    • listInactive: function
      • listInactive(): Promise<unknown[]>

        List inactive (draft) objects on the connected destination.

        Returns Promise<unknown[]>

    • readFile: function
      • readFile(uri: string): Promise<string>

        Read an AFF file's content by repotree URI.

        Parameters

        • uri: string

        Returns Promise<string>

    • search: function
      • search(
            pattern: string,
            opts?: { cold?: boolean; maxResults?: number; types?: string[] },
        ): Promise<QuickSearchResult>

        Search ABAP repository objects by name pattern (e.g. "CL_ABAP*"), optionally filtered by ADT type. cold retries the cold-index window.

        Parameters

        • pattern: string
        • Optionalopts: { cold?: boolean; maxResults?: number; types?: string[] }

        Returns Promise<QuickSearchResult>

    • writeFile: function
      • writeFile(uri: string, content: string): Promise<unknown>

        Write an AFF file (plain multi-line source) by repotree URI.

        Parameters

        • uri: string
        • content: string

        Returns Promise<unknown>

    services: Services

    Runtime + business services: run a console app, service-binding details/publish.

    source: { read(args: ObjectRef & { include?: string }): Promise<string> }

    Read object source by name.

    Type Declaration

    • read: function
      • read(args: ObjectRef & { include?: string }): Promise<string>

        Read an object's source (per include for classes, e.g. include: 'testclasses').

        Parameters

        Returns Promise<string>

    transport: {
        assign(
            args: ObjectRef & { transport: string },
        ): Promise<
            {
                assigned: boolean;
                lockedIn: string[];
                object: string;
                objectType: string;
                transport: string;
            },
        >;
        check(
            args: ObjectRef & {
                operation?: "CREATE" | "MODIFY" | "DELETE";
                recordChanges?: boolean;
                transportLayer?: string;
            },
        ): Promise<unknown>;
        create(
            args: {
                developmentPackage: string;
                isCreation: boolean;
                objectName: string;
                objectType: string;
                transportDescription: string;
            },
        ): Promise<unknown>;
        find(
            args: {
                developmentPackage: string;
                isCreation: boolean;
                objectName: string;
                objectType: string;
            },
        ): Promise<unknown>;
        getDiff(
            transportNumber: string,
            opts?: { cursor?: string; pageSize?: number },
        ): Promise<TransportDiffPage>;
        getLockStatus(
            args: ObjectRef,
        ): Promise<{ lockId: string | null; lockingSupported: boolean }>;
        list(opts?: { limit?: number; query?: string }): Promise<unknown>;
    }

    CTS transport + lock operations.

    Type Declaration

    • assign: function
      • assign(
            args: ObjectRef & { transport: string },
        ): Promise<
            {
                assigned: boolean;
                lockedIn: string[];
                object: string;
                objectType: string;
                transport: string;
            },
        >

        Assign an existing transport to an object. assigned is confirmed by reading the object's CTS lock back (lockedIn = the request(s) it names afterwards).

        Parameters

        Returns Promise<
            {
                assigned: boolean;
                lockedIn: string[];
                object: string;
                objectType: string;
                transport: string;
            },
        >

    • check: function
      • check(
            args: ObjectRef & {
                operation?: "CREATE" | "MODIFY" | "DELETE";
                recordChanges?: boolean;
                transportLayer?: string;
            },
        ): Promise<unknown>

        Transport decision oracle: does this op need a transport, which are assignable, is it locked? (isRecordingRequired:false for $TMP/local.) operation defaults to MODIFY.

        Parameters

        • args: ObjectRef & {
              operation?: "CREATE" | "MODIFY" | "DELETE";
              recordChanges?: boolean;
              transportLayer?: string;
          }

        Returns Promise<unknown>

    • create: function
      • create(
            args: {
                developmentPackage: string;
                isCreation: boolean;
                objectName: string;
                objectType: string;
                transportDescription: string;
            },
        ): Promise<unknown>

        Create a CTS transport request (refuses local $-packages).

        Parameters

        • args: {
              developmentPackage: string;
              isCreation: boolean;
              objectName: string;
              objectType: string;
              transportDescription: string;
          }

        Returns Promise<unknown>

    • find: function
      • find(
            args: {
                developmentPackage: string;
                isCreation: boolean;
                objectName: string;
                objectType: string;
            },
        ): Promise<unknown>

        Object-scoped transport lookup (read-only).

        Parameters

        • args: {
              developmentPackage: string;
              isCreation: boolean;
              objectName: string;
              objectType: string;
          }

        Returns Promise<unknown>

    • getDiff: function
      • getDiff(
            transportNumber: string,
            opts?: { cursor?: string; pageSize?: number },
        ): Promise<TransportDiffPage>

        One page of unified object differences in a transport (1.1.2+, backend-dependent).

        Parameters

        • transportNumber: string
        • Optionalopts: { cursor?: string; pageSize?: number }

        Returns Promise<TransportDiffPage>

    • getLockStatus: function
      • getLockStatus(
            args: ObjectRef,
        ): Promise<{ lockId: string | null; lockingSupported: boolean }>

        Read an object's lock status.

        Parameters

        Returns Promise<{ lockId: string | null; lockingSupported: boolean }>

    • list: function
      • list(opts?: { limit?: number; query?: string }): Promise<unknown>

        List your modifiable transports (capped + filterable).

        Parameters

        • Optionalopts: { limit?: number; query?: string }

        Returns Promise<unknown>

    Methods

    • Shut down: stop the keep-alive, kill adt-ls, close the proxy, and clean temp dirs.

      Returns Promise<void>

    • List the ABAP destinations adt-ls knows (works without a connected destination).

      Returns Promise<unknown>

    • Force a SAP re-logon; true when the session is live afterwards (also auto-heals on dead-session detection).

      Returns Promise<boolean>

    Settings

    Member Visibility

    On This Page

    Properties
    Methods