@patimweb/pi-abap-fs 1.0.0 → 1.1.0

package/README.md

@@ -70,6 +70,14 @@ pi -e ./index.ts
 | `abap_object_types` | List searchable object types |
 | `abap_node_contents` | Browse a package's object tree |
 | `abap_transports` | List transport requests |
+| `abap_atc` | Run ATC analysis on an object |
+| `abap_dumps` | List runtime dumps |
+| `abap_traces` | List performance traces |
+| `abap_trace_hitlist` | Analyze a performance trace |
+| `abap_transport_details` | Details of one transport request |
+| `abap_text_elements` | Read text elements (symbols/selections/headings) |
+| `abap_set_text_elements` | Write text elements |
+| `abap_create_object` | Create a new ABAP object |
 
 ## Example prompts
 

package/index.ts

@@ -23,6 +23,14 @@
  *   - abap_object_types: List searchable object types
  *   - abap_node_contents: Browse package object tree
  *   - abap_transports: List user transports
+ *   - abap_atc: Run ATC analysis
+ *   - abap_dumps: List runtime dumps
+ *   - abap_traces: List performance traces
+ *   - abap_trace_hitlist: Analyze a performance trace
+ *   - abap_transport_details: Details of one transport request
+ *   - abap_text_elements: Read text elements (symbols/selections/headings)
+ *   - abap_set_text_elements: Write text elements
+ *   - abap_create_object: Create a new ABAP object
  *
  * Data-oriented design:
  *   - All domain data is represented as plain immutable interfaces (types.ts)
@@ -54,6 +62,14 @@ import { AbapWhereUsedTool } from "./src/tools/abap-where-used.ts";
 import { AbapObjectTypesTool } from "./src/tools/abap-object-types.ts";
 import { AbapNodeContentsTool } from "./src/tools/abap-node-contents.ts";
 import { AbapTransportsTool } from "./src/tools/abap-transports.ts";
+import { AbapAtcTool } from "./src/tools/abap-atc.ts";
+import { AbapDumpsTool } from "./src/tools/abap-dumps.ts";
+import { AbapTracesTool } from "./src/tools/abap-traces.ts";
+import { AbapTraceHitListTool } from "./src/tools/abap-trace-hitlist.ts";
+import { AbapTransportDetailsTool } from "./src/tools/abap-transport-details.ts";
+import { AbapTextElementsTool } from "./src/tools/abap-text-elements.ts";
+import { AbapSetTextElementsTool } from "./src/tools/abap-set-text-elements.ts";
+import { AbapCreateObjectTool } from "./src/tools/abap-create-object.ts";
 
 export default function (pi: ExtensionAPI) {
   // Load saved config on startup.
@@ -79,4 +95,12 @@ export default function (pi: ExtensionAPI) {
   pi.registerTool(AbapObjectTypesTool);
   pi.registerTool(AbapNodeContentsTool);
   pi.registerTool(AbapTransportsTool);
+  pi.registerTool(AbapAtcTool);
+  pi.registerTool(AbapDumpsTool);
+  pi.registerTool(AbapTracesTool);
+  pi.registerTool(AbapTraceHitListTool);
+  pi.registerTool(AbapTransportDetailsTool);
+  pi.registerTool(AbapTextElementsTool);
+  pi.registerTool(AbapSetTextElementsTool);
+  pi.registerTool(AbapCreateObjectTool);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patimweb/pi-abap-fs",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "ABAP remote filesystem extension for pi coding agent. Read, search, write and activate ABAP objects on SAP systems via the ADT protocol.",
   "keywords": [
     "pi-package",

package/src/formatting/formatters.ts

@@ -16,6 +16,13 @@ import type {
   UsageReference,
   AdtLock,
   SyntaxCheckResult,
+  AtcWorkList,
+  DumpsFeed,
+  TraceResults,
+  TraceHitList,
+  TraceStatementResponse,
+  TransportRequest,
+  TextElementsResult,
 } from "abap-adt-api";
 
 function isClassStructure(
@@ -252,3 +259,124 @@ export function formatSyntaxCheck(results: ReadonlyArray<SyntaxCheckResult>): st
   );
   return `${results.length} message(s):\n${lines.join("\n")}`;
 }
+
+// ATC
+
+export function formatAtcResult(result: AtcWorkList): string {
+  const findings = result.objects.flatMap((o) =>
+    o.findings.map((f) => ({ object: o.name, objectType: o.type, ...f })),
+  );
+  if (findings.length === 0) {
+    return "ATC analysis completed with no findings.";
+  }
+  const lines: string[] = [];
+  for (const { object, objectType, checkTitle, messageTitle, priority, location } of findings) {
+    const pos = location ? `line ${location.range?.start?.line ?? "?"}` : "";
+    lines.push(
+      `- [P${priority}] ${object} (${objectType}): ${checkTitle} — ${messageTitle} ${pos}`,
+    );
+  }
+  lines.unshift(`${findings.length} ATC finding(s):`);
+  return lines.join("\n");
+}
+
+// Dumps
+
+export function formatDumps(feed: DumpsFeed): string {
+  if (feed.dumps.length === 0) return "No runtime dumps found.";
+  const lines = feed.dumps.map((d) => {
+    const when = d.id ? ` [${d.id}]` : "";
+    return `- ${d.type}${when}: ${d.text}`;
+  });
+  return `${feed.dumps.length} runtime dump(s):\n${lines.join("\n")}`;
+}
+
+// Traces
+
+export function formatTraces(result: TraceResults): string {
+  if (result.runs.length === 0) return "No traces found for this user.";
+  const lines = result.runs.map((r) => {
+    const obj = r.extendedData?.objectName
+      ? ` (${r.extendedData.objectName})`
+      : "";
+    const state = r.extendedData?.state?.text ?? "";
+    const runtime = r.extendedData?.runtime
+      ? `${Math.round(r.extendedData.runtime)}s`
+      : "";
+    return `- ${r.title}${obj} [${state}] ${runtime} — id=${r.id}`;
+  });
+  return `${result.runs.length} trace(s):\n${lines.join("\n")}`;
+}
+
+export function formatTraceHitList(
+  hitList: TraceHitList,
+  statements: TraceStatementResponse,
+): string {
+  const lines: string[] = [];
+  if (statements.statements.length > 0) {
+    lines.push("Statements (aggregated call tree):");
+    for (const s of statements.statements.slice(0, 50)) {
+      lines.push(
+        `  - ${s.description} — hits=${s.hitCount}, gross=${s.grossTime.time}ms`,
+      );
+    }
+  }
+  if (hitList.entries.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push("Hit list (hot spots):");
+    const sorted = [...hitList.entries].sort(
+      (a, b) => b.grossTime.time - a.grossTime.time,
+    );
+    for (const e of sorted.slice(0, 25)) {
+      lines.push(
+        `  - ${e.description} — hits=${e.hitCount}, gross=${e.grossTime.time}ms (${e.grossTime.percentage}%)`,
+      );
+    }
+  }
+  if (lines.length === 0) return "Trace has no statements or hit list entries.";
+  return lines.join("\n");
+}
+
+// Transport details
+
+export function formatTransportDetails(request: TransportRequest): string {
+  const lines: string[] = [
+    `Transport: ${request["tm:number"]}`,
+    `Description: ${request["tm:desc"]}`,
+    `Status: ${request["tm:status"]}`,
+    `Owner: ${request["tm:owner"]}`,
+  ];
+  const ownObjects = (request.objects ?? []).map((o) =>
+    `  - ${o["tm:name"]} (${o["tm:type"]})`,
+  );
+  if (ownObjects.length > 0) {
+    lines.push("Objects:");
+    lines.push(...ownObjects);
+  }
+  if (request.tasks.length > 0) {
+    lines.push("Tasks:");
+    for (const t of request.tasks) {
+      lines.push(`  ${t["tm:number"]}: ${t["tm:desc"]}`);
+      for (const o of t.objects ?? []) {
+        lines.push(`    - ${o["tm:name"]} (${o["tm:type"]})`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// Text elements
+
+export function formatTextElements(
+  result: TextElementsResult,
+  category: string,
+): string {
+  if (result.textElements.length === 0) {
+    return `No ${category} text elements found for ${result.programName}.`;
+  }
+  const lines = result.textElements.map((e) => {
+    const extra = e.maxLength ? ` (max ${e.maxLength})` : "";
+    return `- ${e.id} = ${e.text}${extra}`;
+  });
+  return `${result.textElements.length} ${category} text element(s) for ${result.programName}:\n${lines.join("\n")}`;
+}

package/src/tools/abap-atc.ts

@@ -0,0 +1,91 @@
+/**
+ * abap_atc tool — Run ABAP Test Cockpit (ATC) analysis on an object.
+ */
+
+import { Type } from "typebox";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatAtcResult } from "../formatting/formatters.ts";
+
+export const AbapAtcTool = {
+  name: "abap_atc",
+  label: "Run ATC Analysis",
+  description:
+    "Run ABAP Test Cockpit (ATC) analysis on an object and return its findings. Provide the object (name or objectUrl) and optionally a check variant name (default 'DEFAULT'). Use abap_object_types or a known variant name if the default is unavailable.",
+  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'." }),
+    ),
+    variant: Type.Optional(
+      Type.String({
+        description: "ATC check variant / worklist id (default 'DEFAULT').",
+      }),
+    ),
+    maxResults: Type.Optional(
+      Type.Number({ description: "Maximum findings to collect (default 100)." }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      name?: string;
+      objectUrl?: string;
+      type?: string;
+      variant?: string;
+      maxResults?: number;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const { resolved, worklist } = await withClient(config, async (client) => {
+      const resolved = await resolveObject(client, params);
+      const run = await client.createAtcRun(
+        params.variant ?? "DEFAULT",
+        resolved.mainInclude,
+        params.maxResults ?? 100,
+      );
+      const worklist = await client.atcWorklists(run.id);
+      return { resolved, worklist };
+    });
+
+    return {
+      content: [
+        { type: "text" as const, text: formatAtcResult(worklist) },
+      ],
+      details: {
+        name: resolved.name,
+        findingCount: worklist.objects.reduce(
+          (n, o) => n + o.findings.length,
+          0,
+        ),
+        findings: worklist.objects.flatMap((o) =>
+          o.findings.map((f) => ({
+            object: o.name,
+            objectType: o.type,
+            checkId: f.checkId,
+            checkTitle: f.checkTitle,
+            messageId: f.messageId,
+            messageTitle: f.messageTitle,
+            priority: f.priority,
+          })),
+        ),
+      },
+    };
+  },
+};

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

@@ -0,0 +1,128 @@
+/**
+ * abap_create_object tool — Create a new ABAP object (class, program, …).
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+
+const CREATABLE_TYPES = new Set([
+  "CLAS/OC",
+  "INTF/OI",
+  "PROG/P",
+  "PROG/I",
+  "FUGR/F",
+  "FUGR/FF",
+  "FUGR/I",
+  "TABL/DT",
+  "TABL/DS",
+  "DTEL/DE",
+  "DOMA/DD",
+  "DDLS/DF",
+  "DCLS/DL",
+  "DDLX/EX",
+  "DDLA/ADF",
+  "SRVD/SRV",
+  "MSAG/N",
+  "AUTH",
+  "SUSO/B",
+  "DEVC/K",
+]);
+
+/** Resolve the container URI used for function-group includes/modules. */
+function parentPathFor(objectType: string, parentName: string): string {
+  const encoded = encodeURIComponent(parentName.toLowerCase());
+  if (
+    objectType === "FUGR/F" ||
+    objectType === "FUGR/FF" ||
+    objectType === "FUGR/I"
+  ) {
+    return `/sap/bc/adt/functions/groups/${encoded}`;
+  }
+  return parentName ? `/sap/bc/adt/packages/${encoded}` : "";
+}
+
+export const AbapCreateObjectTool = {
+  name: "abap_create_object",
+  label: "Create ABAP Object",
+  description:
+    "Create a new ABAP object programmatically. Provide the object type (e.g. CLAS/OC, INTF/OI, PROG/P, PROG/I, FUGR/F, TABL/DT, DTEL/DE, DOMA/DD, DDLS/DF), the name, the parent package, and a description. The object is created in the given transport (or locally when omitted).",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    objectType: Type.String({
+      description:
+        "Object type, e.g. 'CLAS/OC' (class), 'INTF/OI' (interface), 'PROG/P' (program), 'PROG/I' (include), 'FUGR/F' (function group), 'FUGR/FF' (function module), 'TABL/DT' (table), 'DTEL/DE' (data element), 'DOMA/DD' (domain), 'DDLS/DF' (CDS view).",
+    }),
+    name: Type.String({
+      description: "Object name, e.g. 'ZCL_MY_CLASS'.",
+    }),
+    parentName: Type.String({
+      description:
+        "Parent package name (e.g. 'Z_MY_PACKAGE') — or the function group name for FUGR/FF and FUGR/I. Use '$TMP' for local objects.",
+    }),
+    description: Type.String({
+      description: "Object description.",
+    }),
+    transport: Type.Optional(
+      Type.String({
+        description: "Transport / correction request number.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      objectType: string;
+      name: string;
+      parentName: string;
+      description: string;
+      transport?: string;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const objectType = params.objectType.toUpperCase();
+
+    if (!CREATABLE_TYPES.has(objectType)) {
+      throw new Error(
+        `Unsupported object type "${params.objectType}". Supported: ${[...CREATABLE_TYPES].join(", ")}`,
+      );
+    }
+
+    await withClient(config, (client) =>
+      client.createObject({
+        objtype: objectType as never,
+        name: params.name,
+        parentName: params.parentName,
+        description: params.description,
+        parentPath: parentPathFor(objectType, params.parentName),
+        transport: params.transport,
+        language: config.language ?? "EN",
+      }),
+    );
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text:
+            `Created ${objectType} "${params.name}" in ${params.parentName}.` +
+            (params.transport ? ` Transport: ${params.transport}.` : "") +
+            " Use abap_read to verify and abap_write to add source code.",
+        },
+      ],
+      details: {
+        objectType,
+        name: params.name,
+        parentName: params.parentName,
+        transport: params.transport ?? null,
+      },
+    };
+  },
+};

package/src/tools/abap-dumps.ts

@@ -0,0 +1,51 @@
+/**
+ * abap_dumps tool — List runtime dumps (ABAP short dumps) on the system.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatDumps } from "../formatting/formatters.ts";
+
+export const AbapDumpsTool = {
+  name: "abap_dumps",
+  label: "List ABAP Runtime Dumps",
+  description:
+    "List ABAP runtime dumps (short dumps) on the connected system. Optionally filter with a query string (e.g. a program name).",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    query: Type.Optional(
+      Type.String({
+        description: "Optional filter, e.g. a program name or '*'. Defaults to all dumps.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; query?: string },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const feed = await withClient(config, (client) =>
+      client.dumps(params.query ?? ""),
+    );
+
+    return {
+      content: [{ type: "text" as const, text: formatDumps(feed) }],
+      details: {
+        count: feed.dumps.length,
+        dumps: feed.dumps.map((d) => ({
+          id: d.id,
+          type: d.type,
+          text: d.text,
+          author: d.author,
+        })),
+      },
+    };
+  },
+};

package/src/tools/abap-set-text-elements.ts

@@ -0,0 +1,120 @@
+/**
+ * abap_set_text_elements tool — Write text elements for an ABAP object.
+ */
+
+import { Type } from "typebox";
+import { ADTClient, type TextElement } from "abap-adt-api";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+
+export const AbapSetTextElementsTool = {
+  name: "abap_set_text_elements",
+  label: "Write ABAP Text Elements",
+  description:
+    "Write (save) text elements for an ABAP object. Provide the object (name or objectUrl), the category, and an array of { id, text, maxLength?, ddicReference? }. The object is locked, written and unlocked automatically. Activate afterwards with abap_activate if 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: "Object name, e.g. 'ZCL_MY_CLASS' or a program." }),
+    ),
+    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'." }),
+    ),
+    category: Type.String({
+      description: "Text element category: symbols, selections or headings.",
+    }),
+    elements: Type.Array(
+      Type.Object({
+        id: Type.String({ description: "Text element key, e.g. '001' or 'LISTHEADER'." }),
+        text: Type.String({ description: "Text content." }),
+        maxLength: Type.Optional(
+          Type.Number({ description: "Maximum length (symbols only)." }),
+        ),
+        ddicReference: Type.Optional(
+          Type.String({ description: "DDIC reference (selections only)." }),
+        ),
+      }),
+    ),
+    transport: Type.Optional(
+      Type.String({
+        description: "Transport / correction request number.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      name?: string;
+      objectUrl?: string;
+      type?: string;
+      category: string;
+      elements: Array<{
+        id: string;
+        text: string;
+        maxLength?: number;
+        ddicReference?: string;
+      }>;
+      transport?: string;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const category = params.category as "symbols" | "selections" | "headings";
+    const elements: TextElement[] = params.elements.map((e) => ({
+      id: e.id,
+      text: e.text,
+      ...(e.maxLength !== undefined && { maxLength: e.maxLength }),
+      ...(e.ddicReference !== undefined && { ddicReference: e.ddicReference }),
+    }));
+
+    const resolved = await withClient(
+      config,
+      async (client) => {
+        const resolved = await resolveObject(client, params);
+        const url = ADTClient.textElementsUrl(resolved.type, resolved.name);
+        const lock = await client.lock(resolved.objectUrl, "MODIFY");
+        try {
+          await client.setTextElements(
+            url,
+            category,
+            elements,
+            lock.LOCK_HANDLE,
+            params.transport,
+          );
+        } finally {
+          await client.unLock(resolved.objectUrl, lock.LOCK_HANDLE);
+        }
+        return resolved;
+      },
+      { stateful: true },
+    );
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text:
+            `Wrote ${elements.length} ${category} text element(s) to ${resolved.name}. ` +
+            "Activate the object afterwards if required.",
+        },
+      ],
+      details: {
+        name: resolved.name,
+        category,
+        count: elements.length,
+      },
+    };
+  },
+};

package/src/tools/abap-text-elements.ts

@@ -0,0 +1,80 @@
+/**
+ * abap_text_elements tool — Read text elements (symbols / selection texts / headings).
+ */
+
+import { Type } from "typebox";
+import { ADTClient } from "abap-adt-api";
+import { resolveObject, withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatTextElements } from "../formatting/formatters.ts";
+
+export const AbapTextElementsTool = {
+  name: "abap_text_elements",
+  label: "Read ABAP Text Elements",
+  description:
+    "Read the text elements of an ABAP object: symbols (text symbols), selections (selection texts) or headings. Provide the object (name or objectUrl).",
+  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' or a program." }),
+    ),
+    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'." }),
+    ),
+    category: Type.Optional(
+      Type.String({
+        description: "Text element category: symbols, selections or headings. Default 'symbols'.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: {
+      profile?: string;
+      name?: string;
+      objectUrl?: string;
+      type?: string;
+      category?: string;
+    },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const category = (params.category ?? "symbols") as
+      | "symbols"
+      | "selections"
+      | "headings";
+
+    const { resolved, result } = await withClient(config, async (client) => {
+      const resolved = await resolveObject(client, params);
+      const url = ADTClient.textElementsUrl(resolved.type, resolved.name);
+      const result = await client.getTextElements(url, category);
+      return { resolved, result };
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: formatTextElements(result, category),
+        },
+      ],
+      details: {
+        name: resolved.name,
+        category,
+        count: result.textElements.length,
+        textElements: result.textElements,
+      },
+    };
+  },
+};

package/src/tools/abap-trace-hitlist.ts

@@ -0,0 +1,62 @@
+/**
+ * abap_trace_hitlist tool — Analyze a performance trace (hit list + statements).
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatTraceHitList } from "../formatting/formatters.ts";
+
+export const AbapTraceHitListTool = {
+  name: "abap_trace_hitlist",
+  label: "Analyze ABAP Trace",
+  description:
+    "Analyze an ABAP performance trace: returns the hot-spot hit list and the aggregated statement call tree. Provide the trace id returned by abap_traces.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    traceId: Type.String({
+      description:
+        "Trace id from abap_traces, e.g. '/sap/bc/adt/runtime/traces/abaptraces/...' or the short id.",
+    }),
+    withSystemEvents: Type.Optional(
+      Type.Boolean({
+        description: "Include system events (default false).",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; traceId: string; withSystemEvents?: boolean },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const { hitList, statements } = await withClient(config, async (client) => {
+      const hitList = await client.tracesHitList(
+        params.traceId,
+        params.withSystemEvents ?? false,
+      );
+      const statements = await client.tracesStatements(params.traceId, {
+        withSystemEvents: params.withSystemEvents ?? false,
+      });
+      return { hitList, statements };
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: formatTraceHitList(hitList, statements),
+        },
+      ],
+      details: {
+        hitCount: hitList.entries.length,
+        statementCount: statements.count,
+      },
+    };
+  },
+};

package/src/tools/abap-traces.ts

@@ -0,0 +1,52 @@
+/**
+ * abap_traces tool — List ABAP performance traces for a user.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatTraces } from "../formatting/formatters.ts";
+
+export const AbapTracesTool = {
+  name: "abap_traces",
+  label: "List ABAP Traces",
+  description:
+    "List ABAP performance traces recorded for a user. By default lists the traces of the profile's username. Use abap_trace_hitlist with a trace id to analyze a trace.",
+  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 traces for. Defaults to the connected user.",
+      }),
+    ),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; user?: string },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const result = await withClient(config, (client) =>
+      client.tracesList(params.user ?? config.username),
+    );
+
+    return {
+      content: [{ type: "text" as const, text: formatTraces(result) }],
+      details: {
+        count: result.runs.length,
+        runs: result.runs.map((r) => ({
+          id: r.id,
+          title: r.title,
+          objectName: r.extendedData?.objectName,
+          state: r.extendedData?.state?.text,
+          runtime: r.extendedData?.runtime,
+        })),
+      },
+    };
+  },
+};

package/src/tools/abap-transport-details.ts

@@ -0,0 +1,51 @@
+/**
+ * abap_transport_details tool — Show details of a single transport request.
+ */
+
+import { Type } from "typebox";
+import { withClient } from "../client.ts";
+import { resolveConfig } from "../config.ts";
+import { formatTransportDetails } from "../formatting/formatters.ts";
+
+export const AbapTransportDetailsTool = {
+  name: "abap_transport_details",
+  label: "ABAP Transport Details",
+  description:
+    "Show details of a single transport request: description, status, owner, its tasks and the objects it contains. Provide the transport number (e.g. 'DEVK900123') from abap_transports.",
+  parameters: Type.Object({
+    profile: Type.Optional(
+      Type.String({
+        description: "Profile name to use. Uses active profile if omitted.",
+      }),
+    ),
+    transportNumber: Type.String({
+      description: "Transport request number, e.g. 'DEVK900123'.",
+    }),
+  }),
+
+  async execute(
+    _toolCallId: string,
+    params: { profile?: string; transportNumber: string },
+    _signal: AbortSignal,
+  ) {
+    const config = resolveConfig(params.profile);
+    const request = await withClient(config, (client) =>
+      client.transportDetails(params.transportNumber.toUpperCase()),
+    );
+
+    return {
+      content: [
+        { type: "text" as const, text: formatTransportDetails(request) },
+      ],
+      details: {
+        transport: request["tm:number"],
+        status: request["tm:status"],
+        owner: request["tm:owner"],
+        taskCount: request.tasks.length,
+        objectCount:
+          (request.objects?.length ?? 0) +
+          request.tasks.reduce((n, t) => n + (t.objects?.length ?? 0), 0),
+      },
+    };
+  },
+};