arc-1 0.6.7 → 0.6.9

package/dist/handlers/intent.js

@@ -9,19 +9,21 @@
  * responses. Internal details (stack traces, SAP XML) are NOT
  * leaked to the LLM — only user-friendly error messages.
  */
+import { classifyCdsImpact } from '../adt/cds-impact.js';
 import { findDefinition, findReferences, findWhereUsed, getCompletion, } from '../adt/codeintel.js';
 import { createObject, deleteObject, lockObject, safeUpdateObject, safeUpdateSource, unlockObject, updateObject, } from '../adt/crud.js';
-import { buildDataElementXml, buildDomainXml, buildMessageClassXml, buildPackageXml, buildServiceBindingXml, } from '../adt/ddic-xml.js';
-import { activate, activateBatch, applyFixProposal, getFixProposals, publishServiceBinding, runAtcCheck, runUnitTests, syntaxCheck, unpublishServiceBinding, } from '../adt/devtools.js';
+import { buildDataElementXml, buildDomainXml, buildMessageClassXml, buildPackageXml, buildServiceBindingXml, decodeKtdText, rewriteKtdText, } from '../adt/ddic-xml.js';
+import { activate, activateBatch, applyFixProposal, getFixProposals, getPrettyPrinterSettings, prettyPrint, publishServiceBinding, runAtcCheck, runUnitTests, setPrettyPrinterSettings, syntaxCheck, unpublishServiceBinding, } from '../adt/devtools.js';
 import { getDump, getTraceDbAccesses, getTraceHitlist, getTraceStatements, listDumps, listTraces, } from '../adt/diagnostics.js';
 import { AdtApiError, AdtNetworkError, AdtSafetyError, classifySapDomainError, isNotFoundError, } from '../adt/errors.js';
 import { classifyTextSearchError, mapSapReleaseToAbaplintVersion, probeFeatures } from '../adt/features.js';
 import { addTileToGroup, createCatalog, createGroup, createTile, deleteCatalog, listCatalogs, listGroups, listTiles, } from '../adt/flp.js';
+import { changePackage } from '../adt/refactoring.js';
 import { checkOperation, checkPackage, isOperationAllowed, OperationType } from '../adt/safety.js';
-import { createTransport, deleteTransport, getTransport, getTransportInfo, listTransports, reassignTransport, releaseTransport, releaseTransportRecursive, } from '../adt/transport.js';
+import { createTransport, deleteTransport, getObjectTransports, getTransport, getTransportInfo, listTransports, reassignTransport, releaseTransport, releaseTransportRecursive, } from '../adt/transport.js';
 import { getAppInfo } from '../adt/ui5-repository.js';
 import { validateAffHeader } from '../aff/validator.js';
-import { extractCdsElements } from '../context/cds-deps.js';
+import { extractCdsDependencies, extractCdsElements } from '../context/cds-deps.js';
 import { compressCdsContext, compressContext } from '../context/compressor.js';
 import { extractMethod, formatMethodListing, listMethods, spliceMethod } from '../context/method-surgery.js';
 import { buildLintConfig, listRulesFromConfig, } from '../lint/config-builder.js';
@@ -591,6 +593,21 @@ async function handleSAPRead(client, args, cachingLayer) {
             const { source, cacheHit } = await cachedGet('SRVB', name, () => client.getSrvb(name));
             return cachedTextResult(source, cacheHit);
         }
+        case 'SKTD': {
+            try {
+                // ADT returns a <sktd:docu> XML envelope with the Markdown body base64-encoded
+                // inside <sktd:text>. Cache the raw envelope (update flow re-uses it) and
+                // return the decoded Markdown to the LLM.
+                const { source, cacheHit } = await cachedGet('SKTD', name, () => client.getKtd(name));
+                return cachedTextResult(decodeKtdText(source), cacheHit);
+            }
+            catch (err) {
+                if (isNotFoundError(err)) {
+                    return textResult(`No Knowledge Transfer Document (SKTD) found for "${name}". KTD docs are optional Markdown documentation attached to ABAP objects — either one was never created for "${name}", or the name is wrong.`);
+                }
+                throw err;
+            }
+        }
         case 'TABL': {
             const { source, cacheHit } = await cachedGet('TABL', name, () => client.getTable(name));
             return cachedTextResult(source, cacheHit);
@@ -611,6 +628,58 @@ async function handleSAPRead(client, args, cachingLayer) {
             const dtel = await client.getDataElement(name);
             return textResult(JSON.stringify(dtel, null, 2));
         }
+        case 'AUTH': {
+            const authField = await client.getAuthorizationField(name);
+            return textResult(JSON.stringify(authField, null, 2));
+        }
+        case 'FTG2': {
+            const toggle = await client.getFeatureToggle(name);
+            return textResult(JSON.stringify(toggle, null, 2));
+        }
+        case 'ENHO': {
+            const enhancement = await client.getEnhancementImplementation(name);
+            return textResult(JSON.stringify(enhancement, null, 2));
+        }
+        case 'VERSIONS': {
+            const include = typeof args.include === 'string' ? args.include : undefined;
+            let group = typeof args.group === 'string' ? args.group : undefined;
+            const objectType = normalizeObjectType(String(args.objectType ?? '')) || inferObjectType(name) || 'PROG';
+            if (objectType === 'FUNC' && !group) {
+                const resolved = cachingLayer
+                    ? await cachingLayer.resolveFuncGroup(client, name)
+                    : await client.resolveFunctionGroup(name);
+                if (!resolved) {
+                    return errorResult(`Cannot resolve function group for "${name}". Provide the group parameter explicitly, or use SAPSearch("${name}") to find the function group.`);
+                }
+                group = resolved;
+            }
+            try {
+                const revisions = await client.getRevisions(objectType, name, { include, group });
+                return textResult(JSON.stringify(revisions, null, 2));
+            }
+            catch (err) {
+                if (isNotFoundError(err)) {
+                    return textResult(`No version history available for ${objectType} "${name}" on this SAP system. ` +
+                        `This usually means the object does not exist, or the ADT versions endpoint is not supported for ${objectType} on this backend release.`);
+                }
+                throw err;
+            }
+        }
+        case 'VERSION_SOURCE': {
+            const versionUri = String(args.versionUri ?? '');
+            if (!versionUri) {
+                return errorResult('VERSION_SOURCE requires a versionUri parameter. Get it from SAPRead(type="VERSIONS", name="...") response (.revisions[].uri).');
+            }
+            try {
+                return textResult(await client.getRevisionSource(versionUri));
+            }
+            catch (err) {
+                if (isNotFoundError(err)) {
+                    return errorResult(`Revision at URI "${versionUri}" was not found. The revision may have been removed, or the URI is malformed. Fetch a fresh list via SAPRead(type="VERSIONS", name="...").`);
+                }
+                throw err;
+            }
+        }
         case 'TRAN': {
             const tran = await client.getTransaction(name);
             // Enrich with program name via SQL — only if free SQL is allowed by safety config
@@ -747,7 +816,7 @@ async function handleSAPRead(client, args, cachingLayer) {
             }
         }
         default:
-            return errorResult(`Unknown SAPRead type: "${type}". Supported types: PROG, CLAS, INTF, FUNC, FUGR, INCL, DDLS, DCLS, DDLX, BDEF, SRVD, SRVB, TABL, VIEW, STRU, DOMA, DTEL, TRAN, TABLE_CONTENTS, DEVC, SOBJ, SYSTEM, COMPONENTS, MESSAGES, TEXT_ELEMENTS, VARIANTS, BSP, BSP_DEPLOY, API_STATE, INACTIVE_OBJECTS. ` +
+            return errorResult(`Unknown SAPRead type: "${type}". Supported types: PROG, CLAS, INTF, FUNC, FUGR, INCL, DDLS, DCLS, DDLX, BDEF, SRVD, SRVB, SKTD, TABL, VIEW, STRU, DOMA, DTEL, AUTH, FTG2, ENHO, VERSIONS, VERSION_SOURCE, TRAN, TABLE_CONTENTS, DEVC, SOBJ, SYSTEM, COMPONENTS, MESSAGES, TEXT_ELEMENTS, VARIANTS, BSP, BSP_DEPLOY, API_STATE, INACTIVE_OBJECTS. ` +
                 'Tip: Type aliases are auto-normalized (e.g., DDLS/DF → DDLS, DCLS/DL → DCLS, CLAS/OC → CLAS, PROG/P → PROG). ' +
                 'Do not pass a URI — use the "type" and "name" parameters instead.');
     }
@@ -835,9 +904,8 @@ async function handleSAPQuery(client, args) {
         throw err;
     }
 }
-// _client unused: SAPLint runs offline via @abaplint/core (no SAP round-trip).
-// Signature matches other handlers for consistency with handleToolCall dispatch.
-async function handleSAPLint(_client, args, config) {
+// Some SAPLint actions run offline (@abaplint/core), others call SAP ADT formatter APIs.
+async function handleSAPLint(client, args, config) {
     const action = String(args.action ?? '');
     const ruleOverrides = args.rules;
     const configOptions = buildLintConfigOptions(config, ruleOverrides);
@@ -876,8 +944,33 @@ async function handleSAPLint(_client, args, config) {
                 disabledRuleNames: disabled.map((r) => r.rule),
             }, null, 2));
         }
+        case 'format': {
+            const source = String(args.source ?? '');
+            if (!source)
+                return errorResult('"source" is required for format action.');
+            const formatted = await prettyPrint(client.http, client.safety, source);
+            return textResult(formatted);
+        }
+        case 'get_formatter_settings': {
+            const settings = await getPrettyPrinterSettings(client.http, client.safety);
+            return textResult(JSON.stringify(settings, null, 2));
+        }
+        case 'set_formatter_settings': {
+            const indentation = args.indentation;
+            const style = args.style;
+            if (indentation === undefined && style === undefined) {
+                return errorResult('At least one of "indentation" or "style" is required for set_formatter_settings.');
+            }
+            const current = await getPrettyPrinterSettings(client.http, client.safety);
+            const next = {
+                indentation: indentation ?? current.indentation,
+                style: style ?? current.style,
+            };
+            await setPrettyPrinterSettings(client.http, client.safety, next);
+            return textResult(JSON.stringify(next, null, 2));
+        }
         default:
-            return errorResult(`Unknown SAPLint action: "${action}". Supported: lint, lint_and_fix, list_rules. For atc/syntax/unittest, use SAPDiagnose instead.`);
+            return errorResult(`Unknown SAPLint action: "${action}". Supported: lint, lint_and_fix, list_rules, format, get_formatter_settings, set_formatter_settings. For atc/syntax/unittest, use SAPDiagnose instead.`);
     }
 }
 /**
@@ -904,12 +997,13 @@ const DATAELEMENT_V2_CONTENT_TYPE = 'application/vnd.sap.adt.dataelements.v2+xml
 const SERVICEBINDING_V2_CONTENT_TYPE = 'application/vnd.sap.adt.businessservices.servicebinding.v2+xml; charset=utf-8';
 const BDEF_CONTENT_TYPE = 'application/vnd.sap.adt.blues.v1+xml';
 const MESSAGECLASS_CONTENT_TYPE = 'application/vnd.sap.adt.mc.messageclass+xml';
+const SKTD_V2_CONTENT_TYPE = 'application/vnd.sap.adt.sktdv2+xml';
 function isMetadataWriteType(type) {
     return type === 'DOMA' || type === 'DTEL' || type === 'MSAG' || type === 'SRVB';
 }
 /** Types that require a specific vendor content type for creation (not application/*) */
 function needsVendorContentType(type) {
-    return type === 'DOMA' || type === 'DTEL' || type === 'BDEF' || type === 'MSAG';
+    return type === 'DOMA' || type === 'DTEL' || type === 'BDEF' || type === 'MSAG' || type === 'SKTD';
 }
 /** Content type used for create POST */
 function createContentTypeForType(type) {
@@ -946,6 +1040,8 @@ function vendorContentTypeForType(type) {
             return BDEF_CONTENT_TYPE;
         case 'MSAG':
             return MESSAGECLASS_CONTENT_TYPE;
+        case 'SKTD':
+            return SKTD_V2_CONTENT_TYPE;
         default:
             // Wildcard lets the SAP server resolve the correct handler.
             // Sending 'application/xml' causes 415 on DDL-based endpoints
@@ -1435,6 +1531,7 @@ const SLASH_TYPE_MAP = {
     'DEVC/K': 'DEVC',
     'TRAN/O': 'TRAN',
     'VIEW/V': 'VIEW',
+    'SKTD/TYP': 'SKTD',
 };
 /** Normalize ADT type codes and aliases to ARC-1 canonical short types. */
 export function normalizeObjectType(type) {
@@ -1545,13 +1642,17 @@ function objectBasePath(type) {
             return '/sap/bc/adt/packages/';
         case 'TRAN':
             return '/sap/bc/adt/vit/wb/object_type/trant/object_name/';
+        case 'SKTD':
+            return '/sap/bc/adt/documentation/ktd/documents/';
         default:
             return '/sap/bc/adt/programs/programs/';
     }
 }
 /** Map object type + name to the ADT object URL used by CRUD/DevTools/etc. Name is URI-encoded. */
 function objectUrlForType(type, name) {
-    return `${objectBasePath(type)}${encodeURIComponent(name)}`;
+    // KTD endpoints require lowercase object names in the URL path (confirmed via Eclipse ADT trace).
+    const effectiveName = type === 'SKTD' ? name.toLowerCase() : name;
+    return `${objectBasePath(type)}${encodeURIComponent(effectiveName)}`;
 }
 /** Infer SAP object type from naming conventions. Returns empty string if type cannot be determined. */
 function inferObjectType(name) {
@@ -1569,7 +1670,8 @@ function inferObjectType(name) {
  * Used for API release state where the full URI is encoded as a single path segment by the caller.
  */
 function objectUrlForTypeRaw(type, name) {
-    return `${objectBasePath(type)}${name}`;
+    const effectiveName = type === 'SKTD' ? name.toLowerCase() : name;
+    return `${objectBasePath(type)}${effectiveName}`;
 }
 /** Get the source URL for an object (appends /source/main) */
 function sourceUrlForType(type, name) {
@@ -1602,6 +1704,19 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
     switch (action) {
         case 'update': {
             const existingPackage = await enforcePackageForExistingObject();
+            if (type === 'SKTD') {
+                // KTD update requires the full <sktd:docu> XML envelope with the Markdown
+                // body base64-encoded inside <sktd:text>, PUT with
+                // `application/vnd.sap.adt.sktdv2+xml`. PUTting raw text/plain silently
+                // no-ops (or 415s on strict systems). Fetch the current envelope,
+                // replace only the <sktd:text> body, and PUT it back — preserves
+                // responsible/masterLanguage/packageRef/refObject metadata.
+                const currentEnvelope = await client.getKtd(name);
+                const body = rewriteKtdText(currentEnvelope, source);
+                await safeUpdateObject(client.http, client.safety, objectUrl, body, SKTD_V2_CONTENT_TYPE, transport);
+                cachingLayer?.invalidate(type, name);
+                return textResult(`Successfully updated ${type} ${name}.`);
+            }
             if (isMetadataWriteType(type)) {
                 // Metadata updates are full-XML-replace — we must fetch existing metadata
                 // and merge with provided fields so omitted fields keep their current values.
@@ -1675,6 +1790,45 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
             if (!affResult.valid) {
                 return errorResult(`AFF metadata validation failed for ${type} ${name}:\n- ${(affResult.errors ?? []).join('\n- ')}\n\nFix the metadata and retry.`);
             }
+            if (type === 'SKTD') {
+                // A KTD is not a standalone object — it documents a parent object (e.g., a DDLS view or a CLAS).
+                // The create POST goes to the collection URL with a sktd:docu XML body that references the parent.
+                const refType = String(args.refObjectType ?? '');
+                if (!refType) {
+                    return errorResult('"refObjectType" is required for SKTD create — the ADT type+subtype of the parent object being documented (e.g., "DDLS/DF", "CLAS/OC", "PROG/P", "INTF/OI", "BDEF/BDO", "SRVD/SRV").');
+                }
+                const refName = String(args.refObjectName ?? name);
+                // SAP rule: a KTD's own name must equal the parent object's name (one KTD per object).
+                // Creating a KTD named differently from its parent fails server-side with a cryptic
+                // "Check of condition failed" — fail fast with a clear message instead.
+                if (refName.toUpperCase() !== name.toUpperCase()) {
+                    return errorResult(`SKTD name "${name}" must match refObjectName "${refName}" — a Knowledge Transfer Document inherits the name of the ABAP object it documents (one KTD per object). To document "${refName}", call SAPWrite(action="create", type="SKTD", name="${refName}", refObjectType="${refType}", ...).`);
+                }
+                const refDescription = String(args.refObjectDescription ?? '');
+                // Build the parent URI. ADT URIs use lowercase names by convention (matches the Eclipse trace).
+                const refParentType = refType.split('/')[0] ?? '';
+                const refUri = `${objectBasePath(refParentType)}${encodeURIComponent(refName.toLowerCase())}`;
+                const ktdBody = `<?xml version="1.0" encoding="UTF-8"?>
+<sktd:docu xmlns:sktd="http://www.sap.com/wbobj/texts/sktd" xmlns:adtcore="http://www.sap.com/adt/core" adtcore:language="EN" adtcore:name="${escapeXml(name)}" adtcore:type="SKTD/TYP" adtcore:masterLanguage="EN">
+  <adtcore:packageRef adtcore:name="${escapeXml(pkg)}"/>
+  <sktd:refObject adtcore:description="${escapeXml(refDescription)}" adtcore:name="${escapeXml(refName)}" adtcore:type="${escapeXml(refType)}" adtcore:uri="${escapeXml(refUri)}"/>
+</sktd:docu>`;
+                const ktdCreateUrl = '/sap/bc/adt/documentation/ktd/documents';
+                const ktdResult = await createObject(client.http, client.safety, ktdCreateUrl, ktdBody, SKTD_V2_CONTENT_TYPE, effectiveTransport);
+                // If initial Markdown was provided, follow up with an update PUT to write it.
+                // Same envelope contract as the update path: fetch-then-rewrite ensures we
+                // PUT back exactly the shape SAP gave us (with all the server-assigned
+                // metadata), only swapping <sktd:text>.
+                if (source) {
+                    const currentEnvelope = await client.getKtd(name);
+                    const body = rewriteKtdText(currentEnvelope, source);
+                    await safeUpdateObject(client.http, client.safety, objectUrl, body, SKTD_V2_CONTENT_TYPE, effectiveTransport);
+                    cachingLayer?.invalidate(type, name);
+                    return textResult(`Created SKTD ${name} in package ${pkg} and wrote Markdown content.\nNext step: SAPActivate(type="SKTD", name="${name}").\n${ktdResult}`);
+                }
+                cachingLayer?.invalidate(type, name);
+                return textResult(`Created SKTD ${name} in package ${pkg} (no Markdown content written — pass "source" to write the body).\nNext step: SAPActivate(type="SKTD", name="${name}").\n${ktdResult}`);
+            }
             // Build type-specific creation XML body.
             // SAP ADT requires the root element to match the object type —
             // a generic objectReferences body returns 400 "System expected the element ...".
@@ -1785,7 +1939,7 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
         }
         case 'delete': {
             await enforcePackageForExistingObject();
-            // Lock, delete, unlock pattern — auto-propagate lock corrNr if no explicit transport
+            // Lock, delete, unlock pattern (works for all types including SKTD) — auto-propagate lock corrNr if no explicit transport
             await client.http.withStatefulSession(async (session) => {
                 const lock = await lockObject(session, client.safety, objectUrl);
                 const effectiveTransport = transport ?? (lock.corrNr || undefined);
@@ -2504,14 +2658,56 @@ async function handleSAPTransport(client, args) {
                 summary,
             }, null, 2));
         }
+        case 'history': {
+            const objectType = String(args.type ?? '');
+            const objectName = String(args.name ?? '');
+            if (!objectType || !objectName) {
+                return errorResult('"type" and "name" are required for "history" action.');
+            }
+            const objectUrl = objectUrlForType(objectType, objectName);
+            const primary = await getObjectTransports(client.http, client.safety, objectUrl);
+            let candidateTransports = primary.candidateTransports;
+            // Fallback: if per-object transport lookup is empty, derive the package via
+            // the object metadata endpoint and ask transportchecks for candidate transports.
+            if (primary.relatedTransports.length === 0 && candidateTransports.length === 0) {
+                try {
+                    const pkg = await client.resolveObjectPackage(objectUrl);
+                    if (pkg && pkg !== '$TMP') {
+                        const info = await getTransportInfo(client.http, client.safety, objectUrl, pkg, '');
+                        candidateTransports = info.existingTransports;
+                    }
+                }
+                catch {
+                    // best-effort-fallback
+                }
+            }
+            const lockOwner = primary.relatedTransports[0]?.owner;
+            const summary = primary.lockedTransport
+                ? `Object ${objectName} is locked in transport ${primary.lockedTransport}${lockOwner ? ` by ${lockOwner}` : ''}.`
+                : candidateTransports.length > 0
+                    ? `Object ${objectName} has no active lock; ${candidateTransports.length} transport(s) available for assignment.`
+                    : `Object ${objectName} has no related or candidate transports (likely $TMP / local object).`;
+            const history = {
+                object: { type: objectType, name: objectName, uri: objectUrl },
+                ...(primary.lockedTransport ? { lockedTransport: primary.lockedTransport } : {}),
+                relatedTransports: primary.relatedTransports,
+                candidateTransports,
+                summary,
+            };
+            return textResult(JSON.stringify(history, null, 2));
+        }
         default:
-            return errorResult(`Unknown SAPTransport action: ${action}. Supported: list, get, create, release, delete, reassign, release_recursive, check`);
+            return errorResult(`Unknown SAPTransport action: ${action}. Supported: list, get, create, release, delete, reassign, release_recursive, check, history`);
     }
 }
 // ─── SAPContext Handler ───────────────────────────────────────────────
 async function handleSAPContext(client, args, cachingLayer) {
     const action = String(args.action ?? '');
-    const type = normalizeObjectType(String(args.type ?? ''));
+    // action="impact" is DDLS-only on the server side — default the type so LLMs
+    // don't have to supply it redundantly (and don't get a validation retry when
+    // they don't). Any non-DDLS value still fails the guardrail below.
+    const rawType = String(args.type ?? '');
+    const type = normalizeObjectType(rawType || (action === 'impact' ? 'DDLS' : ''));
     const name = String(args.name ?? '');
     const maxDeps = Number(args.maxDeps ?? 20);
     const depth = Math.min(Math.max(Number(args.depth ?? 1), 1), 3);
@@ -2547,6 +2743,42 @@ async function handleSAPContext(client, args, cachingLayer) {
         const { source } = await cachingLayer.getSource(objType, objName, fetcher);
         return source;
     };
+    if (action === 'impact') {
+        if (type !== 'DDLS') {
+            return errorResult('SAPContext(action="impact") supports DDLS only. For non-CDS objects, use SAPNavigate(action="references").');
+        }
+        const ddlSource = await cachedGet('DDLS', name, () => client.getDdls(name));
+        const upstream = buildCdsUpstream(extractCdsDependencies(ddlSource));
+        const includeIndirect = args.includeIndirect === true;
+        let downstream = classifyCdsImpact([], { includeIndirect });
+        const warnings = [];
+        try {
+            const whereUsed = await findWhereUsed(client.http, client.safety, objectUrlForType('DDLS', name));
+            downstream = classifyCdsImpact(whereUsed, { includeIndirect });
+        }
+        catch (err) {
+            if (err instanceof AdtApiError && [404, 405, 415, 501].includes(err.statusCode)) {
+                warnings.push('Where-used endpoint not available on this system');
+            }
+            else {
+                throw err;
+            }
+        }
+        const upstreamCount = upstream.tables.length + upstream.views.length + upstream.associations.length + upstream.compositions.length;
+        const response = {
+            name,
+            type: 'DDLS',
+            upstream,
+            downstream,
+            summary: {
+                upstreamCount,
+                downstreamTotal: downstream.summary.total,
+                downstreamDirect: downstream.summary.direct,
+            },
+            ...(warnings.length > 0 ? { warnings } : {}),
+        };
+        return textResult(JSON.stringify(response, null, 2));
+    }
     // Get source — either provided or fetched from SAP
     let source;
     if (args.source) {
@@ -2615,6 +2847,45 @@ async function handleSAPContext(client, args, cachingLayer) {
     const result = await compressContext(client, source, name, type, maxDeps, depth, abaplintVersion, cachingLayer);
     return textResult(result.output);
 }
+function buildCdsUpstream(deps) {
+    const tableNames = new Set();
+    const viewNames = new Set();
+    const associationNames = new Set();
+    const compositionNames = new Set();
+    for (const dep of deps) {
+        const upperName = dep.name.toUpperCase();
+        if (dep.kind === 'association') {
+            associationNames.add(upperName);
+            continue;
+        }
+        if (dep.kind === 'composition') {
+            compositionNames.add(upperName);
+            continue;
+        }
+        if (dep.kind === 'projection_base') {
+            viewNames.add(upperName);
+            continue;
+        }
+        if (isLikelyCdsViewName(upperName)) {
+            viewNames.add(upperName);
+        }
+        else {
+            tableNames.add(upperName);
+        }
+    }
+    return {
+        tables: [...tableNames].sort().map((name) => ({ name })),
+        views: [...viewNames].sort().map((name) => ({ name })),
+        associations: [...associationNames].sort().map((name) => ({ name })),
+        compositions: [...compositionNames].sort().map((name) => ({ name })),
+    };
+}
+function isLikelyCdsViewName(name) {
+    if (name.startsWith('/')) {
+        return /\/[ICRPAZ][A-Z0-9_]*_/.test(name);
+    }
+    return /^(ZI_|ZC_|ZR_|ZP_|I_|C_|R_|P_)/.test(name);
+}
 // ─── SAPManage Handler ────────────────────────────────────────────────
 /** Cached feature status — populated on first probe */
 let cachedFeatures;
@@ -2713,6 +2984,72 @@ async function handleSAPManage(client, config, args, cachingLayer, isPerUserClie
             });
             return textResult(`Deleted package ${name}.`);
         }
+        case 'change_package': {
+            const objectName = String(args.objectName ?? '').trim();
+            const objectType = String(args.objectType ?? '').trim();
+            const oldPackage = String(args.oldPackage ?? '').trim();
+            const newPackage = String(args.newPackage ?? '').trim();
+            const transport = String(args.transport ?? '').trim();
+            let objectUri = String(args.objectUri ?? '').trim();
+            if (!objectName)
+                return errorResult('"objectName" is required for change_package action.');
+            if (!objectType)
+                return errorResult('"objectType" is required for change_package action.');
+            if (!oldPackage)
+                return errorResult('"oldPackage" is required for change_package action.');
+            if (!newPackage)
+                return errorResult('"newPackage" is required for change_package action.');
+            checkOperation(client.safety, OperationType.Update, 'ChangePackage');
+            checkPackage(client.safety, oldPackage);
+            checkPackage(client.safety, newPackage);
+            // Resolve object URI via search if not provided
+            if (!objectUri) {
+                const searchResp = await client.http.get(`/sap/bc/adt/repository/informationsystem/search?operation=quickSearch&query=${encodeURIComponent(objectName)}&maxResults=10`);
+                const uriMatch = searchResp.body.match(new RegExp(`adtcore:uri="([^"]*)"[^>]*adtcore:type="${objectType.replace('/', '\\/')}"`, 'i'));
+                if (!uriMatch?.[1]) {
+                    return errorResult(`Could not find object "${objectName}" with type "${objectType}" via ADT search. ` +
+                        `Verify the object exists and the type is correct (e.g., CLAS/OC, DDLS/DF, PROG/P).`);
+                }
+                objectUri = uriMatch[1];
+            }
+            // Transport pre-flight for non-local target packages
+            let effectiveTransport = transport || undefined;
+            if (!effectiveTransport && newPackage.toUpperCase() !== '$TMP') {
+                try {
+                    const transportInfo = await getTransportInfo(client.http, client.safety, objectUri, newPackage, 'I');
+                    if (transportInfo.lockedTransport) {
+                        effectiveTransport = transportInfo.lockedTransport;
+                    }
+                    else if (!transportInfo.isLocal && transportInfo.recording) {
+                        const existingList = transportInfo.existingTransports.length > 0
+                            ? `\n\nExisting transports for this package:\n${transportInfo.existingTransports
+                                .slice(0, 10)
+                                .map((t) => `  - ${t.id}: ${t.description} (${t.owner})`)
+                                .join('\n')}`
+                            : '';
+                        return errorResult(`Package "${newPackage}" requires a transport number for change_package, but none was provided.\n\n` +
+                            `To fix this, either:\n` +
+                            `1. Use SAPTransport(action="list") to find an existing modifiable transport\n` +
+                            `2. Use SAPTransport(action="create", description="...") to create a new one\n` +
+                            `3. Then retry SAPManage(action="change_package", ..., transport="<transport_id>")` +
+                            existingList);
+                    }
+                }
+                catch {
+                    // Graceful fallback: let SAP enforce transport requirements if the pre-check fails.
+                }
+            }
+            const result = await changePackage(client.http, client.safety, {
+                objectUri,
+                objectType,
+                objectName,
+                oldPackage,
+                newPackage,
+                transport: effectiveTransport,
+            });
+            const transportNote = result.transport ? ` (transport: ${result.transport})` : '';
+            return textResult(`Moved ${objectName} from package ${oldPackage} to ${newPackage}${transportNote}.`);
+        }
         case 'flp_list_catalogs': {
             const catalogs = await listCatalogs(client.http, client.safety);
             const customCount = catalogs.filter((c) => /^(Z|Y)/i.test(c.domainId)).length;