arc-1 0.6.4 → 0.6.5

package/dist/handlers/intent.js

@@ -12,7 +12,7 @@
 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, publishServiceBinding, runAtcCheck, runUnitTests, syntaxCheck, unpublishServiceBinding, } from '../adt/devtools.js';
+import { activate, activateBatch, applyFixProposal, getFixProposals, publishServiceBinding, runAtcCheck, runUnitTests, syntaxCheck, unpublishServiceBinding, } from '../adt/devtools.js';
 import { getDump, getTraceDbAccesses, getTraceHitlist, getTraceStatements, listDumps, listTraces, } from '../adt/diagnostics.js';
 import { AdtApiError, AdtNetworkError, AdtSafetyError, isNotFoundError } from '../adt/errors.js';
 import { classifyTextSearchError, mapSapReleaseToAbaplintVersion, probeFeatures } from '../adt/features.js';
@@ -77,6 +77,8 @@ function textResult(text) {
 function errorResult(message) {
     return { content: [{ type: 'text', text: message }], isError: true };
 }
+const DDIC_SAVE_HINT_TYPES = new Set(['TABL', 'DDLS', 'BDEF', 'SRVD', 'SRVB', 'DDLX', 'DOMA', 'DTEL']);
+const DDIC_POST_SAVE_CHECK_TYPES = new Set(['TABL', 'DDLS', 'BDEF', 'SRVD', 'SRVB', 'DDLX']);
 // ─── Search Helpers ─────────────────────────────────────────────────
 /**
  * Transliterate non-ASCII characters in search queries.
@@ -122,6 +124,7 @@ function formatErrorForLLM(err, message, _tool, args) {
     if (err instanceof AdtApiError) {
         // Append additional SAP messages (line numbers, secondary errors) if available
         const enriched = enrichWithSapDetails(err, message);
+        const argType = String(args.type ?? '').toUpperCase();
         if (err.isNotFound) {
             const name = String(args.name ?? '');
             const type = String(args.type ?? '');
@@ -135,6 +138,10 @@ function formatErrorForLLM(err, message, _tool, args) {
         if (transportHint) {
             return `${enriched}\n\nHint: ${transportHint}`;
         }
+        if ((err.statusCode === 400 || err.statusCode === 409) && DDIC_SAVE_HINT_TYPES.has(argType)) {
+            return (`${enriched}\n\nHint: DDIC save failed. Check the diagnostic details above for specific field or annotation errors. ` +
+                'Common fixes: add missing @AbapCatalog annotations, fix field type names, check key field definitions.');
+        }
         // Server errors (500, 502, 503, etc.)
         if (err.isServerError) {
             return `${enriched}\n\nHint: SAP application server error (${err.statusCode}). This is often transient — wait 10-30 seconds and retry. If the error persists, check SAPDiagnose(action="dumps") for short dumps, or verify the SAP system is responding via SAPRead(type="SYSTEM").`;
@@ -156,18 +163,49 @@ function enrichWithSapDetails(err, message) {
     if (extraMessages.length > 0) {
         parts.push(`\nAdditional detail:\n${extraMessages.map((m) => `  - ${m}`).join('\n')}`);
     }
-    // Surface line/column info from properties if present
-    const lineInfo = props.LINE || props['T100KEY-NO'];
-    if (lineInfo || Object.keys(props).length > 0) {
-        const propStr = Object.entries(props)
-            .slice(0, 5) // Limit to avoid overwhelming output
-            .map(([k, v]) => `${k}=${v}`)
-            .join(', ');
-        if (propStr)
-            parts.push(`Properties: ${propStr}`);
+    const ddicDiagnostics = AdtApiError.formatDdicDiagnostics(err.responseBody);
+    if (ddicDiagnostics) {
+        parts.push(ddicDiagnostics);
+        // Skip raw Properties dump — DDIC diagnostics already include the structured
+        // T100KEY details (message ID, number, variables, line). Showing both would
+        // triplicate the same information.
+    }
+    else {
+        // Surface line/column info from properties if present (non-DDIC errors only)
+        const lineInfo = props.LINE || props['T100KEY-NO'];
+        if (lineInfo || Object.keys(props).length > 0) {
+            const propStr = Object.entries(props)
+                .slice(0, 5) // Limit to avoid overwhelming output
+                .map(([k, v]) => `${k}=${v}`)
+                .join(', ');
+            if (propStr)
+                parts.push(`Properties: ${propStr}`);
+        }
     }
     return parts.join('\n');
 }
+async function tryPostSaveSyntaxCheck(client, type, name) {
+    if (!DDIC_POST_SAVE_CHECK_TYPES.has(type.toUpperCase()))
+        return '';
+    try {
+        const checkResult = await syntaxCheck(client.http, client.safety, objectUrlForType(type, name), {
+            version: 'inactive',
+        });
+        if (!checkResult.hasErrors)
+            return '';
+        const errors = checkResult.messages.filter((msg) => msg.severity === 'error');
+        if (errors.length === 0)
+            return '';
+        const lines = errors.map((msg) => {
+            const line = msg.line ? `Line ${msg.line}` : 'Line ?';
+            return `  - ${line}: ${msg.text}`;
+        });
+        return `\nServer syntax check (inactive):\n${lines.join('\n')}`;
+    }
+    catch {
+        return '';
+    }
+}
 /** Detect transport/corrNr failure signatures and return a remediation hint, or undefined if not transport-related. */
 function getTransportHint(err) {
     const body = (err.responseBody ?? '').toLowerCase();
@@ -263,6 +301,7 @@ export async function handleToolCall(client, config, toolName, args, authInfo, _
     // and returns a proper error message with the probe reason when source_code search is unavailable
     const schema = getToolSchema(toolName, isBtp);
     if (schema) {
+        args = normalizeTypeArgsForValidation(toolName, args);
         const parsed = schema.safeParse(args);
         if (!parsed.success) {
             const validationError = formatZodError(parsed.error, toolName);
@@ -397,7 +436,7 @@ const BTP_HINTS = {
     TRAN: 'Transaction codes (TRAN) are not available on BTP ABAP Environment. Use SAPSearch to find apps and services instead.',
 };
 async function handleSAPRead(client, args, cachingLayer) {
-    const type = String(args.type ?? '');
+    const type = normalizeObjectType(String(args.type ?? ''));
     const name = String(args.name ?? '');
     // BTP: return helpful error for unavailable types
     if (isBtpSystem() && BTP_HINTS[type]) {
@@ -574,7 +613,7 @@ async function handleSAPRead(client, args, cachingLayer) {
         }
         case 'API_STATE': {
             // Determine object type for URL construction — use explicit objectType, infer from name, or error
-            const explicitType = String(args.objectType ?? '').toUpperCase();
+            const explicitType = normalizeObjectType(String(args.objectType ?? ''));
             const inferredType = explicitType || inferObjectType(name);
             if (!inferredType) {
                 return errorResult(`Cannot infer object type from name "${name}". Please specify objectType explicitly (e.g., objectType="CLAS", "INTF", "PROG", "TABL", "DDLS", "FUGR", "DOMA", "DTEL", "SRVD", "SRVB", "BDEF").`);
@@ -692,7 +731,7 @@ async function handleSAPRead(client, args, cachingLayer) {
         }
         default:
             return errorResult(`Unknown SAPRead type: "${type}". Supported types: PROG, CLAS, INTF, FUNC, FUGR, INCL, DDLS, 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. ` +
-                'Tip: Map objectType from SAPSearch results by dropping the slash suffix (e.g., DDLS/DF → type="DDLS", CLAS/OC → type="CLAS", PROG/P → type="PROG"). ' +
+                'Tip: Type aliases are auto-normalized (e.g., DDLS/DF → DDLS, CLAS/OC → CLAS, PROG/P → PROG). ' +
                 'Do not pass a URI — use the "type" and "name" parameters instead.');
     }
 }
@@ -706,7 +745,7 @@ async function handleSAPSearch(client, args) {
             return errorResult(`Source code search is not available on this SAP system. ${cachedFeatures.textSearch.reason ?? ''}` +
                 `\nUse SAPSearch with searchType="object" to search by object name instead, or use SAPQuery to search metadata tables.`);
         }
-        const objectType = args.objectType;
+        const objectType = args.objectType ? normalizeObjectType(String(args.objectType)) : undefined;
         const packageName = args.packageName;
         try {
             const results = await client.searchSource(rawQuery, maxResults, objectType, packageName);
@@ -939,6 +978,7 @@ function getMetadataWriteProperties(input) {
         bindingType: input.bindingType,
         category: input.category,
         version: input.version,
+        odataVersion: input.odataVersion,
     };
     return props;
 }
@@ -1016,6 +1056,7 @@ async function mergeMetadataWriteProperties(client, type, name, provided) {
                 bindingType: provided.bindingType ?? existing.bindingType,
                 category: provided.category ?? normalizeSrvbCategory(existing.bindingCategory),
                 version: provided.version ?? existing.serviceVersion,
+                odataVersion: provided.odataVersion ?? existing.odataVersion,
             };
         }
     }
@@ -1233,7 +1274,7 @@ export function buildCreateXml(type, name, pkg, description, properties) {
                 throw new Error('SRVB create/update requires "serviceDefinition" (referenced SRVD name).');
             }
             const categoryRaw = properties?.category;
-            const category = categoryRaw === '1' || categoryRaw === 1 ? '1' : '0';
+            const category = categoryRaw === '1' || categoryRaw === 1 ? '1' : categoryRaw === '0' || categoryRaw === 0 ? '0' : undefined;
             const params = {
                 name,
                 description,
@@ -1242,6 +1283,7 @@ export function buildCreateXml(type, name, pkg, description, properties) {
                 bindingType: properties?.bindingType ? String(properties.bindingType) : undefined,
                 category,
                 version: properties?.version ? String(properties.version) : undefined,
+                odataVersion: properties?.odataVersion ? String(properties.odataVersion) : undefined,
             };
             return buildServiceBindingXml(params);
         }
@@ -1341,6 +1383,97 @@ function escapeXml(s) {
         .replace(/>/g, '>');
 }
 // ─── Object URL Mapping ──────────────────────────────────────────────
+const SLASH_TYPE_MAP = {
+    'PROG/P': 'PROG',
+    'PROG/I': 'INCL',
+    'CLAS/OC': 'CLAS',
+    'CLAS/LI': 'CLAS',
+    'INTF/OI': 'INTF',
+    'FUNC/FM': 'FUNC',
+    'FUGR/F': 'FUGR',
+    'FUGR/FF': 'FUGR',
+    'DDLS/DF': 'DDLS',
+    'BDEF/BDO': 'BDEF',
+    'SRVD/SRV': 'SRVD',
+    'SRVB/SVB': 'SRVB',
+    'DDLX/EX': 'DDLX',
+    'TABL/DT': 'TABL',
+    'STRU/DS': 'STRU',
+    'DOMA/DD': 'DOMA',
+    'DTEL/DE': 'DTEL',
+    'MSAG/N': 'MSAG',
+    'DEVC/K': 'DEVC',
+    'TRAN/O': 'TRAN',
+    'VIEW/V': 'VIEW',
+};
+/** Normalize ADT type codes and aliases to ARC-1 canonical short types. */
+export function normalizeObjectType(type) {
+    const normalized = String(type).trim().toUpperCase();
+    if (!normalized)
+        return '';
+    return SLASH_TYPE_MAP[normalized] ?? normalized;
+}
+/** Normalize type fields before schema validation so slash/case aliases are accepted. */
+function normalizeTypeArgsForValidation(toolName, args) {
+    switch (toolName) {
+        case 'SAPRead':
+            return {
+                ...args,
+                type: normalizeObjectType(String(args.type ?? '')),
+                objectType: args.objectType === undefined ? undefined : normalizeObjectType(String(args.objectType ?? '')),
+            };
+        case 'SAPWrite':
+            return {
+                ...args,
+                type: args.type === undefined ? undefined : normalizeObjectType(String(args.type ?? '')),
+                objects: Array.isArray(args.objects)
+                    ? args.objects.map((obj) => typeof obj === 'object' && obj !== null
+                        ? {
+                            ...obj,
+                            type: normalizeObjectType(String(obj.type ?? '')),
+                        }
+                        : obj)
+                    : args.objects,
+            };
+        case 'SAPActivate':
+            return {
+                ...args,
+                type: args.type === undefined ? undefined : normalizeObjectType(String(args.type ?? '')),
+                objects: Array.isArray(args.objects)
+                    ? args.objects.map((obj) => typeof obj === 'object' && obj !== null
+                        ? {
+                            ...obj,
+                            type: normalizeObjectType(String(obj.type ?? '')),
+                        }
+                        : obj)
+                    : args.objects,
+            };
+        case 'SAPSearch':
+            return {
+                ...args,
+                objectType: args.objectType === undefined ? undefined : normalizeObjectType(String(args.objectType ?? '')),
+            };
+        case 'SAPNavigate':
+            // Only normalize `type` (for URL building). `objectType` is passed to SAP's
+            // where-used scope API in slash format (e.g., CLAS/OC) — normalizing it would break the filter.
+            return {
+                ...args,
+                type: args.type === undefined ? undefined : normalizeObjectType(String(args.type ?? '')),
+            };
+        case 'SAPDiagnose':
+            return {
+                ...args,
+                type: args.type === undefined ? undefined : normalizeObjectType(String(args.type ?? '')),
+            };
+        case 'SAPContext':
+            return {
+                ...args,
+                type: args.type === undefined ? undefined : normalizeObjectType(String(args.type ?? '')),
+            };
+        default:
+            return args;
+    }
+}
 /** Base path for an object type. Returns path prefix without trailing name segment. */
 function objectBasePath(type) {
     switch (type) {
@@ -1413,10 +1546,11 @@ function sourceUrlForType(type, name) {
 // ─── SAPWrite Handler ────────────────────────────────────────────────
 async function handleSAPWrite(client, args, config, cachingLayer) {
     const action = String(args.action ?? '');
-    const type = String(args.type ?? '');
+    const type = normalizeObjectType(String(args.type ?? ''));
     const name = String(args.name ?? '');
     const source = String(args.source ?? '');
     const transport = args.transport;
+    const lintOverride = args.lintBeforeWrite;
     // type and name are required for all actions except batch_create
     if (action !== 'batch_create' && (!type || !name)) {
         return errorResult('"type" and "name" are required for this action.');
@@ -1454,7 +1588,7 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
             if (cdsGuardUpdate)
                 return cdsGuardUpdate;
             // Pre-write lint validation
-            const lintWarnings = runPreWriteLint(source, type, name, config);
+            const lintWarnings = runPreWriteLint(source, type, name, config, lintOverride);
             if (lintWarnings.blocked)
                 return lintWarnings.result;
             await safeUpdateSource(client.http, client.safety, objectUrl, srcUrl, source, transport);
@@ -1520,7 +1654,20 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
             // 'application/*' — the wildcard lets the SAP server resolve the correct
             // handler (matching how ADT Eclipse and abap-adt-api send requests).
             const contentType = createContentTypeForType(type);
-            const result = await createObject(client.http, client.safety, createUrl, body, contentType, effectiveTransport);
+            const needsPackageParam = type === 'BDEF' || type === 'TABL';
+            let result;
+            try {
+                result = await createObject(client.http, client.safety, createUrl, body, contentType, effectiveTransport, needsPackageParam ? pkg : undefined);
+            }
+            catch (createErr) {
+                if (createErr instanceof AdtApiError && (createErr.statusCode === 400 || createErr.statusCode === 409)) {
+                    const syntaxDetail = await tryPostSaveSyntaxCheck(client, type, name);
+                    if (syntaxDetail) {
+                        createErr.message += syntaxDetail;
+                    }
+                }
+                throw createErr;
+            }
             if (isMetadataWriteType(type)) {
                 // SAP's DTEL POST ignores labels, searchHelp, etc. — they require a follow-up PUT.
                 // Use withStatefulSession directly (not safeUpdateObject) to keep the lock cycle
@@ -1561,7 +1708,7 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
             // Step 2: Write source code if provided
             if (source) {
                 // Pre-write lint validation
-                const lintWarnings = runPreWriteLint(source, type, name, config);
+                const lintWarnings = runPreWriteLint(source, type, name, config, lintOverride);
                 if (lintWarnings.blocked) {
                     return textResult(`Created ${type} ${name} in package ${pkg}, but source was rejected by lint:\n${lintWarnings.result.content[0].text}`);
                 }
@@ -1595,7 +1742,7 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
                 return errorResult(spliced.error ?? `Failed to splice method "${method}" in ${name}.`);
             }
             // Pre-write lint validation on the full spliced source
-            const lintWarnings = runPreWriteLint(spliced.newSource, type, name, config);
+            const lintWarnings = runPreWriteLint(spliced.newSource, type, name, config, lintOverride);
             if (lintWarnings.blocked)
                 return lintWarnings.result;
             // Write the full source back (existing lock/modify/unlock flow)
@@ -1639,7 +1786,8 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
                 try {
                     // Use first object's URL for the transport check
                     const firstObj = objects[0];
-                    const firstUrl = objectUrlForType(String(firstObj.type ?? ''), String(firstObj.name ?? ''));
+                    const firstType = normalizeObjectType(String(firstObj?.type ?? ''));
+                    const firstUrl = objectUrlForType(firstType, String(firstObj?.name ?? ''));
                     const transportInfo = await getTransportInfo(client.http, client.safety, firstUrl, pkg, 'I');
                     if (transportInfo.lockedTransport) {
                         batchTransport = transportInfo.lockedTransport;
@@ -1665,7 +1813,7 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
             }
             const results = [];
             for (const obj of objects) {
-                const objType = String(obj.type ?? '');
+                const objType = normalizeObjectType(String(obj.type ?? ''));
                 const objName = String(obj.name ?? '');
                 const metadataObject = isMetadataWriteType(objType);
                 const objSource = obj.source ? String(obj.source) : undefined;
@@ -1685,7 +1833,7 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
                     // Pre-validate source with lint BEFORE creating the object to avoid orphaned objects.
                     // Metadata objects (DOMA/DTEL) are XML-only and intentionally skip source lint.
                     if (!metadataObject && objSource) {
-                        const lintWarnings = runPreWriteLint(objSource, objType, objName, config);
+                        const lintWarnings = runPreWriteLint(objSource, objType, objName, config, lintOverride);
                         if (lintWarnings.blocked) {
                             results.push({
                                 type: objType,
@@ -1702,7 +1850,19 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
                     const objMetadataProps = getMetadataWriteProperties(obj);
                     const body = buildCreateXml(objType, objName, pkg, objDescription, objMetadataProps);
                     const contentType = createContentTypeForType(objType);
-                    await createObject(client.http, client.safety, createUrl, body, contentType, batchTransport);
+                    const needsPackageParam = objType === 'BDEF' || objType === 'TABL';
+                    try {
+                        await createObject(client.http, client.safety, createUrl, body, contentType, batchTransport, needsPackageParam ? pkg : undefined);
+                    }
+                    catch (createErr) {
+                        if (createErr instanceof AdtApiError && (createErr.statusCode === 400 || createErr.statusCode === 409)) {
+                            const syntaxDetail = await tryPostSaveSyntaxCheck(client, objType, objName);
+                            if (syntaxDetail) {
+                                createErr.message += syntaxDetail;
+                            }
+                        }
+                        throw createErr;
+                    }
                     // Step 1b: DTEL POST ignores labels — follow up with PUT on main session
                     if (objType === 'DTEL' && dtelNeedsPostCreateUpdate(objMetadataProps)) {
                         await client.http.withStatefulSession(async (session) => {
@@ -1749,7 +1909,7 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
             for (let i = results.length; i < objects.length; i++) {
                 const skipped = objects[i];
                 results.push({
-                    type: String(skipped.type ?? ''),
+                    type: normalizeObjectType(String(skipped?.type ?? '')),
                     name: String(skipped.name ?? ''),
                     status: 'failed',
                     error: 'skipped — stopped after previous failure',
@@ -1786,8 +1946,20 @@ async function handleSAPWrite(client, args, config, cachingLayer) {
  * If lint itself throws (e.g., abaplint bug on unusual syntax), we don't block
  * the write — we let the SAP server-side syntax check handle it instead.
  */
-function runPreWriteLint(source, type, name, config) {
-    if (!config.lintBeforeWrite || !source) {
+function runPreWriteLint(source, type, name, config, perCallOverride) {
+    // Per-call override takes precedence over server config
+    const enabled = perCallOverride ?? config.lintBeforeWrite;
+    if (!enabled || !source) {
+        return { blocked: false };
+    }
+    // abaplint supports ABAP source (PROG/CLAS/INTF/FUNC/INCL) and CDS views (DDLS) via
+    // its CDS parser. DDLS lint catches syntax errors (cds_parser_error) like missing commas,
+    // wrong keywords, and invalid DDL constructs. BDEF/SRVD/SRVB/DDLX are silently ignored
+    // by abaplint (no parser for those types — garbage passes without errors). TABL (define
+    // table syntax) is not supported by the CDS parser and produces false cds_parser_error.
+    // For unsupported types, SAP server-side compilation handles validation.
+    const LINTABLE_TYPES = new Set(['PROG', 'CLAS', 'INTF', 'FUNC', 'INCL', 'DDLS']);
+    if (!LINTABLE_TYPES.has(type)) {
         return { blocked: false };
     }
     try {
@@ -1894,12 +2066,12 @@ async function handleSAPActivate(client, args) {
         return textResult(`Successfully unpublished service binding ${name}.${srvbInfo ? `\n\n${srvbInfo}` : ''}`);
     }
     // Batch activation: multiple objects at once (for RAP stacks etc.)
-    const type = String(args.type ?? '');
+    const type = normalizeObjectType(String(args.type ?? ''));
     const preaudit = args.preaudit !== undefined ? Boolean(args.preaudit) : undefined;
     const activateOpts = preaudit !== undefined ? { preaudit } : undefined;
     if (args.objects && Array.isArray(args.objects)) {
         const objects = args.objects.map((o) => {
-            const objType = String(o.type ?? type);
+            const objType = normalizeObjectType(String(o.type ?? type));
             const objName = String(o.name ?? '');
             return { url: objectUrlForType(objType, objName), name: objName };
         });
@@ -1955,7 +2127,7 @@ async function handleSAPNavigate(client, args) {
     const source = String(args.source ?? '');
     // Allow symbolic type+name as alternative to uri for references
     if (!uri && args.type && args.name) {
-        const symType = String(args.type);
+        const symType = normalizeObjectType(String(args.type));
         const symName = String(args.name);
         if (symType === 'FUNC') {
             // FUNC needs group to build URL — auto-resolve it
@@ -1986,6 +2158,8 @@ async function handleSAPNavigate(client, args) {
             if (!uri) {
                 return errorResult('Provide uri or type+name to find references.');
             }
+            // objectType is passed to SAP's where-used scope API which expects slash format (CLAS/OC, PROG/P).
+            // Do NOT normalize it — the slash suffix is semantically meaningful for the SAP filter.
             const objectType = args.objectType ? String(args.objectType) : undefined;
             let results;
             try {
@@ -2083,7 +2257,7 @@ async function handleSAPNavigate(client, args) {
 async function handleSAPDiagnose(client, args) {
     const action = String(args.action ?? '');
     const name = String(args.name ?? '');
-    const type = String(args.type ?? '');
+    const type = normalizeObjectType(String(args.type ?? ''));
     switch (action) {
         case 'syntax': {
             const objectUrl = objectUrlForType(type, name);
@@ -2101,6 +2275,52 @@ async function handleSAPDiagnose(client, args) {
             const result = await runAtcCheck(client.http, client.safety, objectUrl, variant);
             return textResult(JSON.stringify(result, null, 2));
         }
+        case 'quickfix': {
+            const source = args.source;
+            if (!name || !type)
+                return errorResult('"name" and "type" are required for "quickfix" action.');
+            if (!source)
+                return errorResult('"source" is required for "quickfix" action.');
+            if (args.line == null)
+                return errorResult('"line" is required for "quickfix" action.');
+            const line = Number(args.line);
+            const column = Number(args.column ?? 0);
+            if (!Number.isFinite(line))
+                return errorResult('"line" must be a number for "quickfix" action.');
+            if (!Number.isFinite(column))
+                return errorResult('"column" must be a number for "quickfix" action.');
+            const proposals = await getFixProposals(client.http, client.safety, sourceUrlForType(type, name), source, line, column);
+            return textResult(JSON.stringify(proposals, null, 2));
+        }
+        case 'apply_quickfix': {
+            const source = args.source;
+            const proposalUri = args.proposalUri;
+            const proposalUserContent = args.proposalUserContent;
+            if (!name || !type)
+                return errorResult('"name" and "type" are required for "apply_quickfix" action.');
+            if (!source)
+                return errorResult('"source" is required for "apply_quickfix" action.');
+            if (args.line == null)
+                return errorResult('"line" is required for "apply_quickfix" action.');
+            if (!proposalUri)
+                return errorResult('"proposalUri" is required for "apply_quickfix" action.');
+            if (!proposalUserContent)
+                return errorResult('"proposalUserContent" is required for "apply_quickfix" action.');
+            const line = Number(args.line);
+            const column = Number(args.column ?? 0);
+            if (!Number.isFinite(line))
+                return errorResult('"line" must be a number for "apply_quickfix" action.');
+            if (!Number.isFinite(column))
+                return errorResult('"column" must be a number for "apply_quickfix" action.');
+            const deltas = await applyFixProposal(client.http, client.safety, {
+                uri: proposalUri,
+                type: 'quickfix/proposal',
+                name: '',
+                description: '',
+                userContent: proposalUserContent,
+            }, sourceUrlForType(type, name), source, line, column);
+            return textResult(JSON.stringify(deltas, null, 2));
+        }
         case 'dumps': {
             const id = args.id;
             if (id) {
@@ -2141,7 +2361,7 @@ async function handleSAPDiagnose(client, args) {
             return textResult(JSON.stringify(traces, null, 2));
         }
         default:
-            return errorResult(`Unknown SAPDiagnose action: ${action}. Supported: syntax, unittest, atc, dumps, traces`);
+            return errorResult(`Unknown SAPDiagnose action: ${action}. Supported: syntax, unittest, atc, quickfix, apply_quickfix, dumps, traces`);
     }
 }
 // ─── SAPTransport Handler ────────────────────────────────────────────
@@ -2240,7 +2460,7 @@ async function handleSAPTransport(client, args) {
 // ─── SAPContext Handler ───────────────────────────────────────────────
 async function handleSAPContext(client, args, cachingLayer) {
     const action = String(args.action ?? '');
-    const type = String(args.type ?? '');
+    const type = normalizeObjectType(String(args.type ?? ''));
     const name = String(args.name ?? '');
     const maxDeps = Number(args.maxDeps ?? 20);
     const depth = Math.min(Math.max(Number(args.depth ?? 1), 1), 3);