@patimweb/pi-abap-fs 1.0.0

package/src/tools/abap-read.ts

@@ -0,0 +1,62 @@
+/**
+ * abap_read tool — Read the source code of an ABAP object.
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+
+export const AbapReadTool = {
+  name: "abap_read",
+  label: "Read ABAP Source",
+  description:
+    "Read the main source code of an ABAP object (class, program, function group, interface, …). Provide either a name (with optional type hint) or an object URL. Returns the full source as text.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    name: Type.Optional(
+      Type.String({ description: "Object name, e.g. 'ZCL_MY_CLASS'" }),
+    ),
+    objectUrl: Type.Optional(
+      Type.String({
+        description:
+          "Object URL, e.g. '/sap/bc/adt/oo/classes/zcl_my_class'. Takes precedence over name.",
+      }),
+    ),
+    type: Type.Optional(
+      Type.String({ description: "Optional type hint for search, e.g. 'CLAS/OC'." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; name?: string; objectUrl?: string; type?: string },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const { source, resolved } = await withClient(config, async (client) => {
+      const resolved = await resolveObject(client, params);
+      const source = await client.getObjectSource(resolved.mainInclude);
+      return { source, resolved };
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: source,
+        },
+      ],
+      details: {
+        name: resolved.name,
+        type: resolved.type,
+        objectUrl: resolved.objectUrl,
+        mainInclude: resolved.mainInclude,
+        lines: source.split("\n").length,
+      },
+    };
+  },
+};

package/src/tools/abap-search.ts

@@ -0,0 +1,67 @@
+/**
+ * abap_search tool — Search ABAP objects by name pattern.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatSearchResults } from "../formatting/formatters.ts";
+
+export const AbapSearchTool = {
+  name: "abap_search",
+  label: "Search ABAP Objects",
+  description:
+    "Search ABAP objects by name pattern (supports wildcards on most systems). Returns object name, type, package and object URL for each match. Use the returned object URL with abap_read, abap_object_structure, etc.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    query: Type.String({
+      description: "Search pattern, e.g. 'ZCL_MY_CLASS' or 'Z*PRICING*'",
+    }),
+    objectType: Type.Optional(
+      Type.String({
+        description:
+          "Optional object type filter. The first part is used, e.g. 'CLAS', 'PROG', 'FUGR', 'INTF', 'TABL'. Use abap_object_types to see available types.",
+      }),
+    ),
+    max: Type.Optional(
+      Type.Number({ description: "Maximum number of results (default 100)." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; query: string; objectType?: string; max?: number },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const max = params.max ?? 100;
+
+    const results = await withClient(config, (client) =>
+      client.searchObject(params.query, params.objectType, max),
+    );
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: formatSearchResults(results, params.query),
+        },
+      ],
+      details: {
+        count: results.length,
+        query: params.query,
+        results: results.map((r) => ({
+          name: r["adtcore:name"],
+          type: r["adtcore:type"],
+          package: r["adtcore:packageName"],
+          description: r["adtcore:description"],
+          objectUrl: r["adtcore:uri"],
+        })),
+      },
+    };
+  },
+};

package/src/tools/abap-setup.ts

@@ -0,0 +1,81 @@
+/**
+ * abap_setup tool — Configure an SAP connection profile.
+ *
+ * Stores a named profile (ADT base URL + credentials). A profile is
+ * automatically set as active if it's the first one. Credentials are stored
+ * in ~/.pi/abap-config.json, readable only by the owner.
+ */
+
+import { Type } from "typebox";
+import { saveProfile } from "../config.ts";
+import type { AbapProfile } from "../types.ts";
+
+export interface SetupParams {
+  name: string;
+  url: string;
+  username: string;
+  password: string;
+  client?: string;
+  language?: string;
+  allowUnauthorized?: boolean;
+}
+
+export const AbapSetupTool = {
+  name: "abap_setup",
+  label: "ABAP Setup",
+  description:
+    "Configure an SAP system connection profile (ADT protocol). Call this first before using any other ABAP tools. Credentials are stored in ~/.pi/abap-config.json (readable only by you). The SAP system must have ADT (ABAP Development Tools) enabled.",
+  parameters: Type.Object({
+    name: Type.String({
+      description:
+        "Profile name, e.g. 'dev', 'prod'. Use a short, memorable name.",
+    }),
+    url: Type.String({
+      description:
+        "ADT base URL, e.g. http://vhcalnplci.bti.local:8000 or https://sap.example.com:44300",
+    }),
+    username: Type.String({
+      description: "SAP logon user (e.g. DEVELOPER)",
+    }),
+    password: Type.String({
+      description: "SAP password",
+    }),
+    client: Type.Optional(
+      Type.String({ description: "SAP client / mandant, e.g. '001'" }),
+    ),
+    language: Type.Optional(
+      Type.String({ description: "Logon language key, e.g. 'EN'" }),
+    ),
+    allowUnauthorized: Type.Optional(
+      Type.Boolean({
+        description:
+          "Accept self-signed TLS certificates. Defaults to false. Set to true only for on-premise dev systems without a valid certificate.",
+      }),
+    ),
+  }),
+
+  async execute(_toolCallId: string, params: SetupParams, _signal: AbortSignal) {
+    const config: AbapProfile = {
+      url: params.url.replace(/\/+$/, ""),
+      username: params.username,
+      password: params.password,
+      ...(params.client !== undefined && { client: params.client }),
+      ...(params.language !== undefined && { language: params.language }),
+      ...(params.allowUnauthorized !== undefined && {
+        allowUnauthorized: params.allowUnauthorized,
+      }),
+    };
+
+    saveProfile(params.name, config);
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `SAP profile "${params.name}" saved and set as active. You can now use all ABAP tools (e.g. abap_test_connection to verify).`,
+        },
+      ],
+      details: { profileName: params.name, configSaved: true },
+    };
+  },
+};

package/src/tools/abap-status.ts

@@ -0,0 +1,32 @@
+/**
+ * abap_status tool — Show current ABAP connection configuration status.
+ */
+
+import { Type } from "typebox";
+import { getProfiles, getActiveProfile } from "../config.ts";
+import { formatProfileStatus } from "../formatting/formatters.ts";
+
+export const AbapStatusTool = {
+  name: "abap_status",
+  label: "ABAP Status",
+  description:
+    "Show current ABAP connection configuration status (which SAP systems are configured and which is active).",
+  parameters: Type.Object({}),
+
+  async execute(_toolCallId: string, _params: {}, _signal: AbortSignal) {
+    const allProfiles = getProfiles();
+    const active = getActiveProfile();
+
+    return {
+      content: [
+        { type: "text" as const, text: formatProfileStatus(allProfiles, active) },
+      ],
+      details: {
+        configured: Object.keys(allProfiles).length > 0,
+        profileCount: Object.keys(allProfiles).length,
+        activeProfile: active,
+        profiles: Object.keys(allProfiles),
+      },
+    };
+  },
+};

package/src/tools/abap-syntax-check.ts

@@ -0,0 +1,76 @@
+/**
+ * abap_syntax_check tool — Run a syntax check on ABAP source.
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatSyntaxCheck } from "../formatting/formatters.ts";
+
+export const AbapSyntaxCheckTool = {
+  name: "abap_syntax_check",
+  label: "ABAP Syntax Check",
+  description:
+    "Run a syntax check on source code. Provide the object (name or objectUrl) and the source to check (for unsaved content), or omit source to check the object's currently saved main include.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    name: Type.Optional(
+      Type.String({ description: "Object name, e.g. 'ZCL_MY_CLASS'" }),
+    ),
+    objectUrl: Type.Optional(
+      Type.String({
+        description:
+          "Object URL, e.g. '/sap/bc/adt/oo/classes/zcl_my_class'. Takes precedence over name.",
+      }),
+    ),
+    type: Type.Optional(
+      Type.String({ description: "Optional type hint for search, e.g. 'CLAS/OC'." }),
+    ),
+    source: Type.Optional(
+      Type.String({
+        description:
+          "Source to check. When omitted, the currently saved main include is checked.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      name?: string;
+      objectUrl?: string;
+      type?: string;
+      source?: string;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const { resolved, results } = await withClient(config, async (client) => {
+      const resolved = await resolveObject(client, params);
+      const source =
+        params.source ?? (await client.getObjectSource(resolved.mainInclude));
+      const results = await client.syntaxCheck(
+        resolved.mainInclude,
+        resolved.mainInclude,
+        source,
+      );
+      return { resolved, results };
+    });
+
+    return {
+      content: [
+        { type: "text" as const, text: formatSyntaxCheck(results) },
+      ],
+      details: {
+        name: resolved.name,
+        messageCount: results.length,
+        messages: results,
+      },
+    };
+  },
+};

package/src/tools/abap-table.ts

@@ -0,0 +1,67 @@
+/**
+ * abap_table tool — Preview the contents of a DDIC table / view.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatQueryResult } from "../formatting/formatters.ts";
+
+export const AbapTableTool = {
+  name: "abap_table",
+  label: "Preview ABAP Table",
+  description:
+    "Preview the contents of a DDIC table or view. Returns the first N rows. Optionally provide a WHERE-style filter via the sqlQuery parameter (empty string returns all rows up to rowNumber).",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    table: Type.String({
+      description: "DDIC table or view name, e.g. 'SFLIGHT' or 'MARA'.",
+    }),
+    rowNumber: Type.Optional(
+      Type.Number({ description: "Maximum rows to return (default 100)." }),
+    ),
+    filter: Type.Optional(
+      Type.String({
+        description:
+          "Optional SQL WHERE condition (without the WHERE keyword), e.g. \"CARRID = 'LH'\".",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      table: string;
+      rowNumber?: number;
+      filter?: string;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const filterSql = params.filter ? `WHERE ${params.filter}` : "";
+    const result = await withClient(config, (client) =>
+      client.tableContents(
+        params.table,
+        params.rowNumber ?? 100,
+        true,
+        filterSql,
+      ),
+    );
+
+    return {
+      content: [
+        { type: "text" as const, text: formatQueryResult(result) },
+      ],
+      details: {
+        table: params.table.toUpperCase(),
+        rowCount: result.values.length,
+        columns: result.columns.map((c) => c.name),
+      },
+    };
+  },
+};

package/src/tools/abap-test-connection.ts

@@ -0,0 +1,54 @@
+/**
+ * abap_test_connection tool — Verify that a profile can log on to the SAP system.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+
+export const AbapTestConnectionTool = {
+  name: "abap_test_connection",
+  label: "Test ABAP Connection",
+  description:
+    "Test the connection to an SAP system by logging in and reading the ADT compatibility graph. Use this to verify a profile works after abap_setup.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+
+    const graph = await withClient(config, async (client) => {
+      const compat = await client.adtCompatibiliyGraph();
+      const discovery = await client.adtCoreDiscovery();
+      return {
+        compatibilityNodes: compat.nodes.map((n) => `${n.nameSpace}:${n.name}`),
+        discoveryTitles: discovery.map((d) => d.title),
+      };
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Connected to ${config.url} as ${config.username}. Login successful.`,
+        },
+      ],
+      details: {
+        url: config.url,
+        username: config.username,
+        client: config.client ?? null,
+        language: config.language ?? null,
+        ...graph,
+      },
+    };
+  },
+};

package/src/tools/abap-transports.ts

@@ -0,0 +1,46 @@
+/**
+ * abap_transports tool — List the transport requests of the current user.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatTransports } from "../formatting/formatters.ts";
+
+export const AbapTransportsTool = {
+  name: "abap_transports",
+  label: "List ABAP Transports",
+  description:
+    "List the transport requests of a user. By default lists the transports of the profile's username. Use the returned transport numbers with abap_write (transport parameter).",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    user: Type.Optional(
+      Type.String({
+        description:
+          "User to list transports for. Defaults to the connected user.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; user?: string },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const transports = await withClient(config, (client) =>
+      client.userTransports(params.user ?? config.username),
+    );
+
+    return {
+      content: [
+        { type: "text" as const, text: formatTransports(transports) },
+      ],
+      details: { transports },
+    };
+  },
+};

package/src/tools/abap-unit-test.ts

@@ -0,0 +1,85 @@
+/**
+ * abap_unit_test tool — Run ABAP unit tests for a class.
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatUnitTests } from "../formatting/formatters.ts";
+
+export const AbapUnitTestTool = {
+  name: "abap_unit_test",
+  label: "Run ABAP Unit Tests",
+  description:
+    "Run ABAP unit tests for a class (or program). Provide the object name or URL. By default only short, harmless tests run; enable dangerous/critical or medium/long durations as needed.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    name: Type.Optional(
+      Type.String({ description: "Class name, e.g. 'ZCL_MY_CLASS'" }),
+    ),
+    objectUrl: Type.Optional(
+      Type.String({
+        description:
+          "Object URL, e.g. '/sap/bc/adt/oo/classes/zcl_my_class'. Takes precedence over name.",
+      }),
+    ),
+    type: Type.Optional(
+      Type.String({ description: "Optional type hint for search, e.g. 'CLAS/OC'." }),
+    ),
+    dangerous: Type.Optional(
+      Type.Boolean({ description: "Include dangerous tests (default false)." }),
+    ),
+    critical: Type.Optional(
+      Type.Boolean({ description: "Include critical tests (default false)." }),
+    ),
+    medium: Type.Optional(
+      Type.Boolean({ description: "Include medium-duration tests (default false)." }),
+    ),
+    long: Type.Optional(
+      Type.Boolean({ description: "Include long-duration tests (default false)." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      name?: string;
+      objectUrl?: string;
+      type?: string;
+      dangerous?: boolean;
+      critical?: boolean;
+      medium?: boolean;
+      long?: boolean;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const { resolved, classes } = await withClient(config, async (client) => {
+      const resolved = await resolveObject(client, params);
+      const classes = await client.unitTestRun(resolved.objectUrl, {
+        harmless: true,
+        dangerous: params.dangerous ?? false,
+        critical: params.critical ?? false,
+        short: true,
+        medium: params.medium ?? false,
+        long: params.long ?? false,
+      });
+      return { resolved, classes };
+    });
+
+    return {
+      content: [
+        { type: "text" as const, text: formatUnitTests(classes) },
+      ],
+      details: {
+        name: resolved.name,
+        testClasses: classes,
+      },
+    };
+  },
+};

package/src/tools/abap-unlock.ts

@@ -0,0 +1,71 @@
+/**
+ * abap_unlock tool — Release a lock previously obtained with abap_lock.
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+
+export const AbapUnlockTool = {
+  name: "abap_unlock",
+  label: "Unlock ABAP Object",
+  description:
+    "Release a lock on an ABAP object. Provide the object URL (or name) and the lock handle returned by abap_lock.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    objectUrl: Type.Optional(
+      Type.String({
+        description: "Object URL, e.g. '/sap/bc/adt/oo/classes/zcl_my_class'.",
+      }),
+    ),
+    name: Type.Optional(
+      Type.String({ description: "Object name (used only if objectUrl omitted)." }),
+    ),
+    type: Type.Optional(
+      Type.String({ description: "Optional type hint for search, e.g. 'CLAS/OC'." }),
+    ),
+    lockHandle: Type.String({
+      description: "The lock handle returned by abap_lock.",
+    }),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      objectUrl?: string;
+      name?: string;
+      type?: string;
+      lockHandle: string;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const resolved = await withClient(
+      config,
+      async (client) => {
+        const resolved = await resolveObject(client, params);
+        await client.unLock(resolved.objectUrl, params.lockHandle);
+        return resolved;
+      },
+      { stateful: true },
+    );
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Unlocked ${resolved.name} (${resolved.objectUrl}).`,
+        },
+      ],
+      details: {
+        name: resolved.name,
+        objectUrl: resolved.objectUrl,
+      },
+    };
+  },
+};