@patimweb/pi-abap-fs 1.0.0

package/src/formatting/formatters.ts

@@ -0,0 +1,254 @@
+/**
+ * Pure formatting functions that convert ADT data into display strings.
+ * No I/O, no state — just data in, string out.
+ */
+
+import type {
+  SearchResult,
+  AbapObjectStructure,
+  ActivationResult,
+  UnitTestClass,
+  QueryResult,
+  NodeStructure,
+  TransportsOfUser,
+  TransportTarget,
+  ObjectTypeDescriptor,
+  UsageReference,
+  AdtLock,
+  SyntaxCheckResult,
+} from "abap-adt-api";
+
+function isClassStructure(
+  s: AbapObjectStructure,
+): s is AbapObjectStructure & { includes: unknown[] } {
+  return Array.isArray((s as { includes?: unknown[] }).includes);
+}
+
+// Search
+
+export function formatSearchResults(
+  results: ReadonlyArray<SearchResult>,
+  query: string,
+): string {
+  if (results.length === 0) {
+    return `No objects found matching "${query}".`;
+  }
+  const lines = results.map((r) => {
+    const parts = [
+      r["adtcore:name"],
+      `type=${r["adtcore:type"]}`,
+    ];
+    if (r["adtcore:packageName"]) parts.push(`package=${r["adtcore:packageName"]}`);
+    if (r["adtcore:description"]) parts.push(r["adtcore:description"]);
+    return `- ${parts.join(" | ")}  (${r["adtcore:uri"]})`;
+  });
+  return `${results.length} object(s) matching "${query}":\n${lines.join("\n")}`;
+}
+
+// Object structure
+
+export function formatObjectStructure(s: AbapObjectStructure): string {
+  const meta = s.metaData;
+  const lines: string[] = [
+    `Name: ${meta["adtcore:name"]}`,
+    `Type: ${meta["adtcore:type"]}`,
+  ];
+  if (meta["adtcore:description"]) lines.push(`Description: ${meta["adtcore:description"]}`);
+  lines.push(`Responsible: ${meta["adtcore:responsible"] ?? "?"}`);
+  lines.push(`Language: ${meta["adtcore:language"] ?? "?"}`);
+  if (isClassStructure(s)) {
+    lines.push("Includes:");
+    for (const inc of s.includes as Array<{ "class:includeType": string }>) {
+      lines.push(`  - ${inc["class:includeType"]}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// Activation
+
+export function formatActivation(result: ActivationResult): string {
+  if (result.success) {
+    return "Activation successful.";
+  }
+  const lines = ["Activation failed."];
+  if (result.messages.length > 0) {
+    lines.push("Messages:");
+    for (const m of result.messages) {
+      lines.push(`  - [${m.type}] ${m.shortText} (line ${m.line})`);
+    }
+  }
+  if (result.inactive.length > 0) {
+    lines.push("Inactive objects:");
+    for (const rec of result.inactive) {
+      if (rec.object) {
+        lines.push(`  - ${rec.object["adtcore:name"]} (${rec.object["adtcore:type"]}) by ${rec.object.user}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// Unit tests
+
+export function formatUnitTests(classes: ReadonlyArray<UnitTestClass>): string {
+  if (classes.length === 0) {
+    return "No test classes found or no tests were executed.";
+  }
+  const lines: string[] = [];
+  let totalMethods = 0;
+  let failures = 0;
+  for (const c of classes) {
+    lines.push(`Class: ${c["adtcore:name"]} (risk=${c.riskLevel})`);
+    for (const m of c.testmethods) {
+      totalMethods++;
+      const alert = m.alerts.find((a) => a.severity === "critical" || a.severity === "fatal");
+      const status = alert ? `FAILED (${alert.severity})` : "passed";
+      if (alert) failures++;
+      lines.push(`  - ${m["adtcore:name"]}: ${status}`);
+      if (alert) {
+        lines.push(`      ${alert.title}`);
+        for (const d of alert.details.slice(0, 5)) {
+          lines.push(`      ${d.split("\n").join("\n      ")}`);
+        }
+      }
+    }
+  }
+  lines.unshift(`${totalMethods} test method(s), ${failures} failure(s).`);
+  return lines.join("\n");
+}
+
+// Query / table results
+
+export function formatQueryResult(result: QueryResult): string {
+  const { columns, values } = result;
+  if (values.length === 0) {
+    return "Query returned no rows.";
+  }
+  const names = columns.map((c) => c.name);
+  const rows = values.map((row) =>
+    names.map((n) => {
+      const v = (row as Record<string, unknown>)[n];
+      return v === null || v === undefined ? "" : String(v);
+    }),
+  );
+  // Simple aligned table
+  const widths = names.map((n, i) =>
+    Math.max(n.length, ...rows.map((r) => r[i]?.length ?? 0)),
+  );
+  const fmt = (cells: string[]) =>
+    cells.map((c, i) => c.padEnd(widths[i])).join(" | ");
+  const lines = [
+    fmt(names),
+    widths.map((w) => "-".repeat(w)).join("-+-"),
+    ...rows.map(fmt),
+  ];
+  lines.push(`\n${values.length} row(s).`);
+  return lines.join("\n");
+}
+
+// Node contents (package / object tree)
+
+export function formatNodes(structure: NodeStructure): string {
+  if (structure.nodes.length === 0) {
+    return "No child objects found.";
+  }
+  const lines = structure.nodes.map((n) => {
+    const desc = n.DESCRIPTION ? ` (${n.DESCRIPTION})` : "";
+    return `- ${n.OBJECT_NAME}  [${n.OBJECT_TYPE}]${desc}`;
+  });
+  return `${structure.nodes.length} node(s):\n${lines.join("\n")}`;
+}
+
+// Object types
+
+export function formatObjectTypes(types: ReadonlyArray<ObjectTypeDescriptor>): string {
+  if (types.length === 0) return "No object types available.";
+  const lines = types.map(
+    (t) => `- ${t.name} (${t.type}) — ${t.description ?? ""}`,
+  );
+  return `${types.length} object type(s):\n${lines.join("\n")}`;
+}
+
+// Transports
+
+function targetRequests(t: TransportTarget): string[] {
+  return [...t.modifiable, ...t.released].map((r) => {
+    return `  - ${r["tm:number"]} [${r["tm:status"]}] ${r["tm:desc"]} (owner=${r["tm:owner"]})`;
+  });
+}
+
+export function formatTransports(transports: TransportsOfUser): string {
+  const allTargets = [
+    ...transports.workbench.map((t) => ({ kind: "Workbench", t })),
+    ...transports.customizing.map((t) => ({ kind: "Customizing", t })),
+  ];
+  const lines: string[] = [];
+  for (const { kind, t } of allTargets) {
+    const requests = targetRequests(t);
+    if (requests.length === 0) continue;
+    lines.push(`${kind} target ${t["tm:name"]} (${t["tm:desc"]}):`);
+    lines.push(...requests);
+  }
+  if (lines.length === 0) return "No transport requests found for this user.";
+  return lines.join("\n");
+}
+
+// Where-used
+
+export function formatUsageReferences(references: ReadonlyArray<UsageReference>): string {
+  if (references.length === 0) return "No usage references found.";
+  const lines = references.map((r) => {
+    const name = r["adtcore:name"] || r.objectIdentifier;
+    return `- ${name} (${r["adtcore:type"] ?? "?"})`;
+  });
+  return `${references.length} usage reference(s):\n${lines.join("\n")}`;
+}
+
+// Lock
+
+export function formatLock(lock: AdtLock): string {
+  return [
+    `Locked. lockHandle=${lock.LOCK_HANDLE}`,
+    lock.CORRNR ? `Transport: ${lock.CORRNR} (${lock.CORRTEXT ?? ""})` : "Transport: (none)",
+    lock.CORRUSER ? `Correction user: ${lock.CORRUSER}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+// Syntax check
+
+export function formatProfileStatus(
+  profiles: Record<string, import("../types.ts").AbapProfile>,
+  activeProfile: string | null,
+): string {
+  const names = Object.keys(profiles);
+  if (names.length === 0) {
+    return "No SAP connection configured. Use the abap_setup tool to configure a system.";
+  }
+  const lines: string[] = [
+    `${names.length} SAP profile${names.length === 1 ? "" : "s"} configured:`,
+    "",
+  ];
+  for (const name of names) {
+    const cfg = profiles[name];
+    const marker = name === activeProfile ? "[active]" : "       ";
+    lines.push(`${marker} ${name}: ${cfg.username}@${cfg.url}`);
+    const extra = [
+      cfg.client ? `client=${cfg.client}` : "",
+      cfg.language ? `lang=${cfg.language}` : "",
+      cfg.allowUnauthorized ? "insecure-tls" : "",
+    ].filter(Boolean);
+    if (extra.length > 0) lines.push(`       ${extra.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+export function formatSyntaxCheck(results: ReadonlyArray<SyntaxCheckResult>): string {
+  if (results.length === 0) return "No syntax errors found.";
+  const lines = results.map(
+    (r) => `- [${r.severity}] line ${r.line}: ${r.text}`,
+  );
+  return `${results.length} message(s):\n${lines.join("\n")}`;
+}

package/src/tools/abap-activate.ts

@@ -0,0 +1,73 @@
+/**
+ * abap_activate tool — Activate an ABAP object.
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatActivation } from "../formatting/formatters.ts";
+
+export const AbapActivateTool = {
+  name: "abap_activate",
+  label: "Activate ABAP Object",
+  description:
+    "Activate an ABAP object after writing changes. Provide the object (name or objectUrl). Returns activation messages and any inactive objects that resulted.",
+  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'." }),
+    ),
+    preauditRequested: Type.Optional(
+      Type.Boolean({ description: "Request a pre-activation audit (default true)." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      name?: string;
+      objectUrl?: string;
+      type?: string;
+      preauditRequested?: boolean;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const { resolved, activation } = await withClient(config, async (client) => {
+      const resolved = await resolveObject(client, params);
+      const activation = await client.activate(
+        resolved.name,
+        resolved.objectUrl,
+        resolved.mainInclude,
+        params.preauditRequested ?? true,
+      );
+      return { resolved, activation };
+    });
+
+    return {
+      content: [
+        { type: "text" as const, text: formatActivation(activation) },
+      ],
+      details: {
+        name: resolved.name,
+        success: activation.success,
+        messages: activation.messages,
+        inactive: activation.inactive,
+      },
+    };
+  },
+};

package/src/tools/abap-lock.ts

@@ -0,0 +1,79 @@
+/**
+ * abap_lock tool — Lock an ABAP object for editing (returns a lock handle).
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatLock } from "../formatting/formatters.ts";
+
+export const AbapLockTool = {
+  name: "abap_lock",
+  label: "Lock ABAP Object",
+  description:
+    "Lock an ABAP object for editing. Returns a lock handle that must be passed to abap_write or released with abap_unlock when done. Provide either a name (with optional type hint) or an object URL.",
+  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'." }),
+    ),
+    accessMode: Type.Optional(
+      Type.String({ description: "Lock access mode, e.g. 'MODIFY' (default) or 'EDIT'." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      name?: string;
+      objectUrl?: string;
+      type?: string;
+      accessMode?: string;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const result = await withClient(
+      config,
+      async (client) => {
+        const resolved = await resolveObject(client, params);
+        const lock = await client.lock(
+          resolved.objectUrl,
+          params.accessMode ?? "MODIFY",
+        );
+        return { resolved, lock };
+      },
+      { stateful: true },
+    );
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: formatLock(result.lock),
+        },
+      ],
+      details: {
+        name: result.resolved.name,
+        objectUrl: result.resolved.objectUrl,
+        mainInclude: result.resolved.mainInclude,
+        lockHandle: result.lock.LOCK_HANDLE,
+        corrNr: result.lock.CORRNR,
+      },
+    };
+  },
+};

package/src/tools/abap-node-contents.ts

@@ -0,0 +1,57 @@
+/**
+ * abap_node_contents tool — Browse the object tree of a package (or program / function group).
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatNodes } from "../formatting/formatters.ts";
+
+export const AbapNodeContentsTool = {
+  name: "abap_node_contents",
+  label: "Browse ABAP Object Tree",
+  description:
+    "Browse the contents of an SAP package (or program / function group) to discover the objects inside it. parentType is usually 'DEVC/K' for packages; pass the package name as parentName. Use '$TMP' for local objects.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    parentType: Type.String({
+      description: "Parent object type: DEVC/K (package), PROG/P (program), FUGR/F (function group), PROG/PI (include).",
+    }),
+    parentName: Type.Optional(
+      Type.String({
+        description: "Parent object name, e.g. 'Z_MY_PACKAGE' or '$TMP'. Omit to list the top level.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; parentType: string; parentName?: string },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const structure = await withClient(config, (client) =>
+      client.nodeContents(
+        params.parentType as "DEVC/K" | "PROG/P" | "FUGR/F" | "PROG/PI",
+        params.parentName,
+      ),
+    );
+
+    return {
+      content: [{ type: "text" as const, text: formatNodes(structure) }],
+      details: {
+        nodeCount: structure.nodes.length,
+        nodes: structure.nodes.map((n) => ({
+          name: n.OBJECT_NAME,
+          type: n.OBJECT_TYPE,
+          description: n.DESCRIPTION,
+          uri: n.OBJECT_URI,
+        })),
+      },
+    };
+  },
+};

package/src/tools/abap-object-structure.ts

@@ -0,0 +1,60 @@
+/**
+ * abap_object_structure tool — Read an object's metadata and includes.
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatObjectStructure } from "../formatting/formatters.ts";
+
+export const AbapObjectStructureTool = {
+  name: "abap_object_structure",
+  label: "ABAP Object Structure",
+  description:
+    "Get metadata (type, description, responsible, language) and include list for an ABAP object, plus the main source URL. Provide either a name (with optional type hint) or an object URL.",
+  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 resolved = await withClient(config, (client) =>
+      resolveObject(client, params),
+    );
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: formatObjectStructure(resolved.structure),
+        },
+      ],
+      details: {
+        name: resolved.name,
+        type: resolved.type,
+        objectUrl: resolved.objectUrl,
+        mainInclude: resolved.mainInclude,
+      },
+    };
+  },
+};

package/src/tools/abap-object-types.ts

@@ -0,0 +1,38 @@
+/**
+ * abap_object_types tool — List searchable object types and their descriptors.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatObjectTypes } from "../formatting/formatters.ts";
+
+export const AbapObjectTypesTool = {
+  name: "abap_object_types",
+  label: "List ABAP Object Types",
+  description:
+    "List the object types available for searching on the connected system. Useful to discover the correct type hint for abap_search (e.g. CLAS, PROG, FUGR, INTF).",
+  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 types = await withClient(config, (client) => client.objectTypes());
+
+    return {
+      content: [
+        { type: "text" as const, text: formatObjectTypes(types) },
+      ],
+      details: { count: types.length, types },
+    };
+  },
+};

package/src/tools/abap-profile.ts

@@ -0,0 +1,87 @@
+/**
+ * abap_profile tool — List, switch or delete configured SAP profiles.
+ */
+
+import { Type } from "typebox";
+import {
+  deleteProfile,
+  getActiveProfile,
+  getProfiles,
+  setActiveProfile,
+} from "../config.ts";
+import { formatProfileStatus } from "../formatting/formatters.ts";
+
+export const AbapProfileTool = {
+  name: "abap_profile",
+  label: "Manage ABAP Profiles",
+  description:
+    "List configured SAP connection profiles, switch the active one, or delete a profile. Without arguments it lists all profiles.",
+  parameters: Type.Object({
+    action: Type.Optional(
+      Type.String({
+        description: "One of: list, use, delete. Defaults to list.",
+      }),
+    ),
+    name: Type.Optional(
+      Type.String({ description: "Profile name for 'use' and 'delete'." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { action?: string; name?: string },
+    _signal: AbortSignal,
+  ): Promise<{
+    content: { type: "text"; text: string }[];
+    details: Record<string, unknown>;
+  }> {
+    const action = (params.action || "list").toLowerCase();
+
+    if (action === "list") {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: formatProfileStatus(getProfiles(), getActiveProfile()),
+          },
+        ],
+        details: {
+          profiles: Object.keys(getProfiles()),
+          activeProfile: getActiveProfile(),
+        },
+      };
+    }
+
+    if (!params.name) {
+      throw new Error(`The "${action}" action requires a profile name.`);
+    }
+
+    if (action === "use") {
+      setActiveProfile(params.name);
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Active SAP profile is now "${params.name}".`,
+          },
+        ],
+        details: { activeProfile: params.name },
+      };
+    }
+
+    if (action === "delete") {
+      const removed = deleteProfile(params.name);
+      const text = removed
+        ? `Profile "${params.name}" deleted. Active profile is now ${getActiveProfile() ? `"${getActiveProfile()}"` : "unset"}.`
+        : `No profile named "${params.name}".`;
+      return {
+        content: [{ type: "text" as const, text }],
+        details: { deleted: removed, activeProfile: getActiveProfile() },
+      };
+    }
+
+    throw new Error(
+      `Unknown action "${params.action}". Use one of: list, use, delete.`,
+    );
+  },
+};

package/src/tools/abap-query.ts

@@ -0,0 +1,50 @@
+/**
+ * abap_query tool — Run an ABAP SQL (freestyle) query on the connected system.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatQueryResult } from "../formatting/formatters.ts";
+
+export const AbapQueryTool = {
+  name: "abap_query",
+  label: "Run ABAP SQL Query",
+  description:
+    "Run an ABAP SQL SELECT query on the connected SAP system (freestyle data preview). Returns rows as text. Example: SELECT * FROM sflight UP TO 10 ROWS. Use with care on production systems.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    sql: Type.String({
+      description:
+        "ABAP SQL SELECT statement, e.g. 'SELECT carrid, connid, fldate FROM sflight UP TO 20 ROWS'.",
+    }),
+    rowNumber: Type.Optional(
+      Type.Number({ description: "Maximum rows to return (default 100)." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; sql: string; rowNumber?: number },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const result = await withClient(config, (client) =>
+      client.runQuery(params.sql, params.rowNumber ?? 100),
+    );
+
+    return {
+      content: [
+        { type: "text" as const, text: formatQueryResult(result) },
+      ],
+      details: {
+        rowCount: result.values.length,
+        columns: result.columns.map((c) => c.name),
+      },
+    };
+  },
+};