arc-1 0.6.8 → 0.6.10

package/dist/handlers/intent.js

@@ -9,20 +9,23 @@
  * responses. Internal details (stack traces, SAP XML) are NOT
  * leaked to the LLM — only user-friendly error messages.
  */
+import { checkRepo as abapGitCheckRepo, createBranch as abapGitCreateBranch, createRepo as abapGitCreateRepo, getExternalInfo as abapGitGetExternalInfo, listRepos as abapGitListRepos, pullRepo as abapGitPullRepo, pushRepo as abapGitPushRepo, stageRepo as abapGitStageRepo, switchBranch as abapGitSwitchBranch, unlinkRepo as abapGitUnlinkRepo, } from '../adt/abapgit.js';
+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, decodeKtdText, rewriteKtdText, } from '../adt/ddic-xml.js';
-import { activate, activateBatch, applyFixProposal, getFixProposals, publishServiceBinding, runAtcCheck, runUnitTests, syntaxCheck, unpublishServiceBinding, } from '../adt/devtools.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 { cloneRepo as gctsCloneRepo, commitRepo as gctsCommitRepo, createBranch as gctsCreateBranch, deleteRepo as gctsDeleteRepo, getCommitHistory as gctsGetCommitHistory, getConfig as gctsGetConfig, getUserInfo as gctsGetUserInfo, listBranches as gctsListBranches, listRepoObjects as gctsListRepoObjects, listRepos as gctsListRepos, pullRepo as gctsPullRepo, switchBranch as gctsSwitchBranch, } from '../adt/gcts.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';
@@ -47,6 +50,7 @@ export const TOOL_SCOPES = {
     SAPRead: 'read',
     SAPSearch: 'read',
     SAPQuery: 'sql',
+    SAPGit: 'read',
     SAPNavigate: 'read',
     SAPContext: 'read',
     SAPLint: 'read',
@@ -56,6 +60,24 @@ export const TOOL_SCOPES = {
     SAPManage: 'write',
     SAPTransport: 'write',
 };
+const SAPGIT_ACTION_SCOPES = {
+    list_repos: 'read',
+    whoami: 'read',
+    config: 'read',
+    branches: 'read',
+    external_info: 'read',
+    history: 'read',
+    objects: 'read',
+    check: 'read',
+    clone: 'write',
+    pull: 'write',
+    push: 'write',
+    commit: 'write',
+    stage: 'write',
+    switch_branch: 'write',
+    create_branch: 'write',
+    unlink: 'write',
+};
 /**
  * Check if authInfo has the required scope, respecting implied scopes:
  * - `write` implies `read`
@@ -365,6 +387,9 @@ export async function handleToolCall(client, config, toolName, args, authInfo, _
                 case 'SAPTransport':
                     result = await handleSAPTransport(client, args);
                     break;
+                case 'SAPGit':
+                    result = await handleSAPGit(client, args, authInfo);
+                    break;
                 case 'SAPContext':
                     result = await handleSAPContext(client, args, cachingLayer);
                     break;
@@ -627,6 +652,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
@@ -763,7 +840,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, SKTD, 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.');
     }
@@ -851,9 +928,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);
@@ -892,8 +968,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.`);
     }
 }
 /**
@@ -2492,6 +2593,217 @@ async function handleSAPDiagnose(client, args) {
             return errorResult(`Unknown SAPDiagnose action: ${action}. Supported: syntax, unittest, atc, quickfix, apply_quickfix, dumps, traces`);
     }
 }
+function resolveSapGitBackend(args) {
+    const forced = args.backend;
+    const hasGcts = Boolean(cachedFeatures?.gcts?.available);
+    const hasAbapGit = Boolean(cachedFeatures?.abapGit?.available);
+    if (!hasGcts && !hasAbapGit) {
+        return {
+            error: 'Neither gCTS nor abapGit is available on this SAP system. Run SAPManage(action="probe") to refresh feature detection.',
+        };
+    }
+    if (forced) {
+        if (forced === 'gcts' && !hasGcts)
+            return { error: 'gCTS backend is not available on this SAP system.' };
+        if (forced === 'abapgit' && !hasAbapGit)
+            return { error: 'abapGit backend is not available on this SAP system.' };
+        return { backend: forced };
+    }
+    return { backend: hasGcts ? 'gcts' : 'abapgit' };
+}
+async function loadAbapGitRepo(client, repoId) {
+    const repos = await abapGitListRepos(client.http, client.safety);
+    const repo = repos.find((candidate) => candidate.key === repoId);
+    if (!repo) {
+        throw new Error(`abapGit repository "${repoId}" was not found. Run SAPGit(action="list_repos", backend="abapgit").`);
+    }
+    return repo;
+}
+async function handleSAPGit(client, args, authInfo) {
+    const action = String(args.action ?? '');
+    const scope = SAPGIT_ACTION_SCOPES[action];
+    if (!scope) {
+        return errorResult(`Unknown SAPGit action: ${action}`);
+    }
+    if (authInfo && !hasRequiredScope(authInfo, scope)) {
+        return errorResult(`Insufficient scope: '${scope}' required for SAPGit(action="${action}"). Your scopes: [${authInfo.scopes.join(', ')}]`);
+    }
+    const resolved = resolveSapGitBackend(args);
+    if (!resolved.backend) {
+        return errorResult(resolved.error ?? 'Unable to resolve SAPGit backend.');
+    }
+    const backend = resolved.backend;
+    const repoId = String(args.repoId ?? '').trim();
+    const url = String(args.url ?? '').trim();
+    const branch = String(args.branch ?? '').trim();
+    const packageName = String(args.package ?? '').trim();
+    const user = String(args.user ?? '').trim() || undefined;
+    const password = String(args.password ?? '').trim() || undefined;
+    const token = String(args.token ?? '').trim() || undefined;
+    const limit = Number(args.limit ?? 20);
+    const gctsOnlyActions = new Set(['whoami', 'config', 'branches', 'history', 'objects', 'commit']);
+    const abapGitOnlyActions = new Set(['external_info', 'check', 'stage', 'push']);
+    if (backend === 'abapgit' && gctsOnlyActions.has(action)) {
+        return errorResult(`Action '${action}' is only supported by gCTS; this system uses abapGit.`);
+    }
+    if (backend === 'gcts' && abapGitOnlyActions.has(action)) {
+        return errorResult(`Action '${action}' is only supported by abapGit; this system uses gCTS.`);
+    }
+    let result;
+    switch (action) {
+        case 'list_repos':
+            result =
+                backend === 'gcts'
+                    ? await gctsListRepos(client.http, client.safety)
+                    : await abapGitListRepos(client.http, client.safety);
+            break;
+        case 'whoami':
+            result = await gctsGetUserInfo(client.http, client.safety);
+            break;
+        case 'config':
+            result = await gctsGetConfig(client.http, client.safety, repoId || undefined);
+            break;
+        case 'branches':
+            if (!repoId)
+                return errorResult('SAPGit(action="branches") requires repoId.');
+            result = await gctsListBranches(client.http, client.safety, repoId);
+            break;
+        case 'external_info':
+            if (!url)
+                return errorResult('SAPGit(action="external_info") requires url.');
+            result = await abapGitGetExternalInfo(client.http, client.safety, url, user, password);
+            break;
+        case 'history':
+            if (!repoId)
+                return errorResult('SAPGit(action="history") requires repoId.');
+            result = await gctsGetCommitHistory(client.http, client.safety, repoId, Number.isFinite(limit) ? limit : 20);
+            break;
+        case 'objects':
+            if (!repoId)
+                return errorResult('SAPGit(action="objects") requires repoId.');
+            result = await gctsListRepoObjects(client.http, client.safety, repoId);
+            break;
+        case 'check': {
+            if (!repoId)
+                return errorResult('SAPGit(action="check") requires repoId.');
+            const repo = await loadAbapGitRepo(client, repoId);
+            result = await abapGitCheckRepo(client.http, client.safety, repo);
+            break;
+        }
+        case 'stage': {
+            if (!repoId)
+                return errorResult('SAPGit(action="stage") requires repoId.');
+            const repo = await loadAbapGitRepo(client, repoId);
+            result = await abapGitStageRepo(client.http, client.safety, repo);
+            break;
+        }
+        case 'clone':
+            if (!url)
+                return errorResult('SAPGit(action="clone") requires url.');
+            if (backend === 'gcts') {
+                const params = {
+                    rid: repoId || undefined,
+                    name: repoId || undefined,
+                    url,
+                    ...(packageName ? { package: packageName } : {}),
+                    user,
+                    password,
+                    token,
+                };
+                result = await gctsCloneRepo(client.http, client.safety, params);
+            }
+            else {
+                if (!packageName)
+                    return errorResult('SAPGit(action="clone", backend="abapgit") requires package.');
+                result = await abapGitCreateRepo(client.http, client.safety, {
+                    package: packageName,
+                    url,
+                    branchName: branch || undefined,
+                    transportRequest: String(args.transport ?? '').trim() || undefined,
+                    user,
+                    password,
+                });
+            }
+            break;
+        case 'pull':
+            if (!repoId)
+                return errorResult('SAPGit(action="pull") requires repoId.');
+            if (backend === 'gcts') {
+                result = await gctsPullRepo(client.http, client.safety, repoId, String(args.commit ?? '').trim() || undefined);
+            }
+            else {
+                result = await abapGitPullRepo(client.http, client.safety, repoId, {
+                    ...(packageName ? { package: packageName } : {}),
+                    ...(url ? { url } : {}),
+                    ...(branch ? { branchName: branch } : {}),
+                    transportRequest: String(args.transport ?? '').trim() || undefined,
+                    user,
+                    password,
+                });
+            }
+            break;
+        case 'push': {
+            if (!repoId)
+                return errorResult('SAPGit(action="push") requires repoId.');
+            const repo = await loadAbapGitRepo(client, repoId);
+            const staging = Array.isArray(args.objects) && args.objects.length > 0
+                ? { repoKey: repo.key, branchName: repo.branchName, objects: args.objects }
+                : await abapGitStageRepo(client.http, client.safety, repo);
+            await abapGitPushRepo(client.http, client.safety, repo, staging);
+            result = { ok: true };
+            break;
+        }
+        case 'commit':
+            if (!repoId)
+                return errorResult('SAPGit(action="commit") requires repoId.');
+            result = await gctsCommitRepo(client.http, client.safety, repoId, {
+                message: String(args.message ?? '').trim() || undefined,
+                description: String(args.description ?? '').trim() || undefined,
+                objects: Array.isArray(args.objects) ? args.objects : undefined,
+            });
+            break;
+        case 'switch_branch':
+            if (!repoId || !branch)
+                return errorResult('SAPGit(action="switch_branch") requires repoId and branch.');
+            if (backend === 'gcts') {
+                result = await gctsSwitchBranch(client.http, client.safety, repoId, branch);
+            }
+            else {
+                await abapGitSwitchBranch(client.http, client.safety, repoId, branch, false);
+                result = { ok: true };
+            }
+            break;
+        case 'create_branch':
+            if (!repoId || !branch)
+                return errorResult('SAPGit(action="create_branch") requires repoId and branch.');
+            if (backend === 'gcts') {
+                result = await gctsCreateBranch(client.http, client.safety, repoId, {
+                    branch,
+                    ...(packageName ? { package: packageName } : {}),
+                });
+            }
+            else {
+                await abapGitCreateBranch(client.http, client.safety, repoId, branch);
+                result = { ok: true };
+            }
+            break;
+        case 'unlink':
+            if (!repoId)
+                return errorResult('SAPGit(action="unlink") requires repoId.');
+            if (backend === 'gcts') {
+                await gctsDeleteRepo(client.http, client.safety, repoId);
+            }
+            else {
+                await abapGitUnlinkRepo(client.http, client.safety, repoId);
+            }
+            result = { ok: true };
+            break;
+        default:
+            return errorResult(`Unknown SAPGit action: ${action}`);
+    }
+    const payload = backend === 'gcts' || backend === 'abapgit' ? { backend, result } : result;
+    return textResult(JSON.stringify(payload, null, 2));
+}
 // ─── SAPTransport Handler ────────────────────────────────────────────
 async function handleSAPTransport(client, args) {
     const action = String(args.action ?? '');
@@ -2581,14 +2893,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);
@@ -2624,6 +2978,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) {
@@ -2692,6 +3082,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;