gitnexus 1.4.10 → 1.5.1

package/dist/core/ingestion/cobol/cobol-preprocessor.js

@@ -69,21 +69,59 @@ export function preprocessCobolSource(content) {
 // Preserved exactly: EXCLUDED_PARA_NAMES
 // ---------------------------------------------------------------------------
 // COBOL calling-convention keywords to filter from USING parameter lists
-const USING_KEYWORDS = new Set(['BY', 'VALUE', 'REFERENCE', 'CONTENT', 'ADDRESS', 'OF', 'RETURNING']);
+const USING_KEYWORDS = new Set([
+    'BY',
+    'VALUE',
+    'REFERENCE',
+    'CONTENT',
+    'ADDRESS',
+    'OF',
+    'RETURNING',
+]);
 // CALL ... USING keyword filter (extends USING_KEYWORDS for CALL-specific forms)
 const CALL_USING_FILTER = new Set([
-    'BY', 'REFERENCE', 'CONTENT', 'VALUE',
-    'ADDRESS', 'OF', 'LENGTH', 'OMITTED',
+    'BY',
+    'REFERENCE',
+    'CONTENT',
+    'VALUE',
+    'ADDRESS',
+    'OF',
+    'LENGTH',
+    'OMITTED',
 ]);
 const EXCLUDED_PARA_NAMES = new Set([
-    'DECLARATIVES', 'END', 'PROCEDURE', 'IDENTIFICATION',
-    'ENVIRONMENT', 'DATA', 'WORKING-STORAGE', 'LINKAGE',
-    'FILE', 'LOCAL-STORAGE', 'COMMUNICATION', 'REPORT',
-    'SCREEN', 'INPUT-OUTPUT', 'CONFIGURATION',
+    'DECLARATIVES',
+    'END',
+    'PROCEDURE',
+    'IDENTIFICATION',
+    'ENVIRONMENT',
+    'DATA',
+    'WORKING-STORAGE',
+    'LINKAGE',
+    'FILE',
+    'LOCAL-STORAGE',
+    'COMMUNICATION',
+    'REPORT',
+    'SCREEN',
+    'INPUT-OUTPUT',
+    'CONFIGURATION',
     // COBOL verbs that appear alone on a line with period (false-positive in free-format)
-    'GOBACK', 'STOP', 'EXIT', 'CONTINUE',
-    'DISPLAY', 'ACCEPT', 'WRITE', 'READ', 'REWRITE', 'DELETE',
-    'OPEN', 'CLOSE', 'RETURN', 'RELEASE', 'SORT', 'MERGE',
+    'GOBACK',
+    'STOP',
+    'EXIT',
+    'CONTINUE',
+    'DISPLAY',
+    'ACCEPT',
+    'WRITE',
+    'READ',
+    'REWRITE',
+    'DELETE',
+    'OPEN',
+    'CLOSE',
+    'RETURN',
+    'RELEASE',
+    'SORT',
+    'MERGE',
 ]);
 // ---------------------------------------------------------------------------
 // Regex constants (compiled once, reused across calls)
@@ -145,8 +183,16 @@ const RE_SET_INDEX = /\bSET\s+((?:[A-Z][A-Z0-9-]+\s+)+)(TO|UP\s+BY|DOWN\s+BY)\s+
 // INITIALIZE statement — data reset (captures targets before REPLACING/WITH clause)
 const RE_INITIALIZE = /\bINITIALIZE\s+([\s\S]*?)(?=\bREPLACING\b|\bWITH\b|\.\s*$|$)/i;
 const INITIALIZE_CLAUSE_KEYWORDS = new Set([
-    'REPLACING', 'WITH', 'ALL', 'ALPHABETIC', 'ALPHANUMERIC',
-    'NUMERIC', 'NATIONAL', 'DBCS', 'EGCS', 'FILLER',
+    'REPLACING',
+    'WITH',
+    'ALL',
+    'ALPHABETIC',
+    'ALPHANUMERIC',
+    'NUMERIC',
+    'NATIONAL',
+    'DBCS',
+    'EGCS',
+    'FILLER',
 ]);
 // EXEC DLI (IMS/DB)
 const RE_EXEC_DLI_START = /\bEXEC\s+DLI\b/i;
@@ -157,8 +203,16 @@ const RE_ENTRY = /\bENTRY\s+(?:"([^"]+)"|'([^']+)')(?:\s+USING\s+([\s\S]*?))?(?:
 // MOVE statement — captures everything after TO for multi-target extraction
 const RE_MOVE = /\bMOVE\s+((?:CORRESPONDING|CORR)\s+)?([A-Z][A-Z0-9-]+)\s+TO\s+(.+)/i;
 const MOVE_SKIP = new Set([
-    'SPACES', 'ZEROS', 'ZEROES', 'LOW-VALUES', 'LOW-VALUE',
-    'HIGH-VALUES', 'HIGH-VALUE', 'QUOTES', 'QUOTE', 'ALL',
+    'SPACES',
+    'ZEROS',
+    'ZEROES',
+    'LOW-VALUES',
+    'LOW-VALUE',
+    'HIGH-VALUES',
+    'HIGH-VALUE',
+    'QUOTES',
+    'QUOTE',
+    'ALL',
 ]);
 /**
  * Parse the text after "MOVE ... TO" into an array of target variable names.
@@ -172,7 +226,7 @@ function extractMoveTargets(afterTo) {
         return [];
     // Remove subscript/reference-modification parenthesized suffixes
     const noSubscripts = text.replace(/\([^)]*\)/g, '');
-    const tokens = noSubscripts.split(/\s+/).filter(t => t.length > 0);
+    const tokens = noSubscripts.split(/\s+/).filter((t) => t.length > 0);
     const targets = [];
     const QUAL_KEYWORDS = new Set(['OF', 'IN']);
     let skipNext = false;
@@ -194,14 +248,27 @@ function extractMoveTargets(afterTo) {
 // PERFORM: keywords that may follow PERFORM but are NOT paragraph/section names.
 // Inline PERFORM loops (UNTIL, VARYING) and inline test clauses (WITH TEST,
 // FOREVER) must not be stored as perform-target false positives.
-const PERFORM_KEYWORD_SKIP = new Set([
-    'UNTIL', 'VARYING', 'WITH', 'TEST', 'FOREVER',
-]);
+const PERFORM_KEYWORD_SKIP = new Set(['UNTIL', 'VARYING', 'WITH', 'TEST', 'FOREVER']);
 // SORT/MERGE clause keywords that should not be captured as file names
 const SORT_CLAUSE_NOISE = new Set([
-    'ON', 'ASCENDING', 'DESCENDING', 'KEY', 'WITH', 'DUPLICATES',
-    'IN', 'ORDER', 'COLLATING', 'SEQUENCE', 'IS', 'THROUGH', 'THRU',
-    'INPUT', 'OUTPUT', 'PROCEDURE', 'USING', 'GIVING',
+    'ON',
+    'ASCENDING',
+    'DESCENDING',
+    'KEY',
+    'WITH',
+    'DUPLICATES',
+    'IN',
+    'ORDER',
+    'COLLATING',
+    'SEQUENCE',
+    'IS',
+    'THROUGH',
+    'THRU',
+    'INPUT',
+    'OUTPUT',
+    'PROCEDURE',
+    'USING',
+    'GIVING',
 ]);
 // COBOL statement verbs used as boundary detectors across accumulators.
 // Shared by: callAccum flush trigger, inspectAccum flush trigger, and USING lookahead.
@@ -209,20 +276,46 @@ const SORT_CLAUSE_NOISE = new Set([
 // Including CALL here would cause the flush trigger to consume the new CALL line
 // without re-detecting it as a CALL start.
 const COBOL_STATEMENT_VERBS = [
-    'GO\\s+TO', 'PERFORM', 'MOVE', 'DISPLAY', 'ACCEPT',
-    'INSPECT', 'SEARCH', 'SORT', 'MERGE', 'IF', 'EVALUATE',
-    'SET', 'INITIALIZE', 'STOP', 'EXIT', 'GOBACK', 'CONTINUE',
-    'READ', 'WRITE', 'REWRITE', 'DELETE', 'OPEN', 'CLOSE', 'START',
-    'CANCEL', 'COMPUTE', 'ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE',
-    'STRING', 'UNSTRING',
+    'GO\\s+TO',
+    'PERFORM',
+    'MOVE',
+    'DISPLAY',
+    'ACCEPT',
+    'INSPECT',
+    'SEARCH',
+    'SORT',
+    'MERGE',
+    'IF',
+    'EVALUATE',
+    'SET',
+    'INITIALIZE',
+    'STOP',
+    'EXIT',
+    'GOBACK',
+    'CONTINUE',
+    'READ',
+    'WRITE',
+    'REWRITE',
+    'DELETE',
+    'OPEN',
+    'CLOSE',
+    'START',
+    'CANCEL',
+    'COMPUTE',
+    'ADD',
+    'SUBTRACT',
+    'MULTIPLY',
+    'DIVIDE',
+    'STRING',
+    'UNSTRING',
 ];
 /** Regex matching start of any COBOL statement verb (for accumulator flush triggers). */
 const RE_STATEMENT_VERB_START = new RegExp(`^(?:${COBOL_STATEMENT_VERBS.join('|')})(?:\\s|$)`, 'i');
 /** Lookahead alternation for USING parameter extraction (stops before statement verbs).
  *  Includes CALL (excluded from COBOL_STATEMENT_VERBS to avoid callAccum conflicts). */
 const USING_VERB_LOOKAHEAD = [...COBOL_STATEMENT_VERBS, 'CALL']
-    .filter(v => v !== 'GO\\s+TO') // GO TO handled separately with \bGO\s+TO\b
-    .map(v => `\\b${v}(?=\\s|$)`)
+    .filter((v) => v !== 'GO\\s+TO') // GO TO handled separately with \bGO\s+TO\b
+    .map((v) => `\\b${v}(?=\\s|$)`)
     .join('|');
 const RE_USING_PARAMS = new RegExp(`\\bUSING\\s+([\\s\\S]*?)(?=\\bRETURNING\\b|\\bON\\s+(?:EXCEPTION|OVERFLOW)\\b|\\bNOT\\s+ON\\b|\\bEND-CALL\\b|\\bGO\\s+TO\\b|${USING_VERB_LOOKAHEAD}|\\.\\s*$|$)`, 'i');
 // ---------------------------------------------------------------------------
@@ -290,12 +383,17 @@ function parseDataItemClauses(rest) {
     if (!result.value) {
         const valueIdx = text.search(/\bVALUE\b/i);
         if (valueIdx >= 0) {
-            const afterValue = text.substring(valueIdx + 5).replace(/^\s+IS\s+/i, '').trimStart();
+            const afterValue = text
+                .substring(valueIdx + 5)
+                .replace(/^\s+IS\s+/i, '')
+                .trimStart();
             // Try quoted: "..." or '...' (with optional type prefix X, N, G, B)
             const quotedMatch = afterValue.match(/^([XNGB])?(?:"([^"]*)"|'([^']*)')/i);
             if (quotedMatch) {
                 const prefix = quotedMatch[1] ? quotedMatch[1].toUpperCase() : '';
-                result.value = prefix ? `${prefix}'${quotedMatch[2] ?? quotedMatch[3]}'` : (quotedMatch[2] ?? quotedMatch[3]);
+                result.value = prefix
+                    ? `${prefix}'${quotedMatch[2] ?? quotedMatch[3]}'`
+                    : (quotedMatch[2] ?? quotedMatch[3]);
             }
             else {
                 // Try ALL "..." or ALL '...'
@@ -407,8 +505,14 @@ function parseExecSqlBlock(block, line) {
     // Determine operation from first SQL keyword
     const firstWord = body.split(/\s+/)[0]?.toUpperCase() || '';
     const OP_MAP = {
-        SELECT: 'SELECT', INSERT: 'INSERT', UPDATE: 'UPDATE', DELETE: 'DELETE',
-        DECLARE: 'DECLARE', OPEN: 'OPEN', CLOSE: 'CLOSE', FETCH: 'FETCH',
+        SELECT: 'SELECT',
+        INSERT: 'INSERT',
+        UPDATE: 'UPDATE',
+        DELETE: 'DELETE',
+        DECLARE: 'DECLARE',
+        OPEN: 'OPEN',
+        CLOSE: 'CLOSE',
+        FETCH: 'FETCH',
         INCLUDE: 'OTHER', // we handle INCLUDE specially below
     };
     const operation = OP_MAP[firstWord] || 'OTHER';
@@ -469,11 +573,21 @@ function parseExecCicsBlock(block, line) {
         .trim();
     // Command: first keyword(s) — handle two-word commands like SEND MAP, RECEIVE MAP
     const twoWordCommands = [
-        'SEND MAP', 'RECEIVE MAP', 'SEND TEXT', 'SEND CONTROL',
-        'READ NEXT', 'READ PREV',
-        'WRITEQ TS', 'WRITEQ TD', 'READQ TS', 'READQ TD',
-        'DELETEQ TS', 'DELETEQ TD',
-        'HANDLE ABEND', 'HANDLE AID', 'HANDLE CONDITION',
+        'SEND MAP',
+        'RECEIVE MAP',
+        'SEND TEXT',
+        'SEND CONTROL',
+        'READ NEXT',
+        'READ PREV',
+        'WRITEQ TS',
+        'WRITEQ TD',
+        'READQ TS',
+        'READQ TD',
+        'DELETEQ TS',
+        'DELETEQ TD',
+        'HANDLE ABEND',
+        'HANDLE AID',
+        'HANDLE CONDITION',
         'START TRANSID',
     ];
     let command = '';
@@ -531,7 +645,11 @@ function parseExecCicsBlock(block, line) {
 // Private helper: parse EXEC DLI block (IMS/DB)
 // ---------------------------------------------------------------------------
 function parseExecDliBlock(block, line) {
-    const body = block.replace(/\bEXEC\s+DLI\b/i, '').replace(/\bEND-EXEC\b/i, '').replace(/\s+/g, ' ').trim();
+    const body = block
+        .replace(/\bEXEC\s+DLI\b/i, '')
+        .replace(/\bEND-EXEC\b/i, '')
+        .replace(/\s+/g, ' ')
+        .trim();
     const verb = body.split(/\s+/)[0]?.toUpperCase() || '';
     const result = { line, verb };
     const pcbMatch = body.match(/\bUSING\s+PCB\s*\(\s*(\d+)\s*\)/i);
@@ -878,8 +996,11 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
                     currentParagraph = null;
                     const procUsingMatch = line.match(RE_PROC_USING);
                     if (procUsingMatch) {
-                        const params = procUsingMatch[1].split(/\bRETURNING\b/i)[0].trim().split(/\s+/)
-                            .filter(s => s.length > 0 && !USING_KEYWORDS.has(s.toUpperCase()));
+                        const params = procUsingMatch[1]
+                            .split(/\bRETURNING\b/i)[0]
+                            .trim()
+                            .split(/\s+/)
+                            .filter((s) => s.length > 0 && !USING_KEYWORDS.has(s.toUpperCase()));
                         result.procedureUsing = params;
                         // Store per-program on the boundary stack
                         const topProg = programBoundaryStack[programBoundaryStack.length - 1];
@@ -955,10 +1076,11 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
             // Only use RE_PROC_PARAGRAPH as flush trigger when in Area A (≤7 leading spaces, fixed-format).
             // In free-format, never use RE_PROC_PARAGRAPH (can't distinguish parameters from paragraphs).
             const trimmedLine = line.trimStart();
-            const leadingSpaces = (line.match(/^(\s*)/)?.[1].length ?? 0);
+            const leadingSpaces = line.match(/^(\s*)/)?.[1].length ?? 0;
             const isAreaAParagraph = RE_PROC_PARAGRAPH.test(line) && (!isFreeFormat ? leadingSpaces <= 7 : false);
-            if (RE_STATEMENT_VERB_START.test(trimmedLine)
-                || RE_PROC_SECTION.test(line) || isAreaAParagraph) {
+            if (RE_STATEMENT_VERB_START.test(trimmedLine) ||
+                RE_PROC_SECTION.test(line) ||
+                isAreaAParagraph) {
                 flushCallAccum(); // Flush CALL without this line's content
                 // Fall through to process this line normally
             }
@@ -970,7 +1092,8 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
                 return; // continuation line consumed by CALL accumulator
             }
         }
-        else if (currentDivision === 'procedure' && /(?<![A-Z0-9-])\bCALL\s+(?:"[^"]+"|'[^']+'|[A-Z][A-Z0-9-]+)/i.test(line)) {
+        else if (currentDivision === 'procedure' &&
+            /(?<![A-Z0-9-])\bCALL\s+(?:"[^"]+"|'[^']+'|[A-Z][A-Z0-9-]+)/i.test(line)) {
             // Check if this is a complete single-line CALL (ends with period or END-CALL)
             if (/\.\s*$/.test(line) || /\bEND-CALL\b/i.test(line)) {
                 // Single-line CALL — extract immediately via flushCallAccum
@@ -1018,7 +1141,11 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
             // Detect COMMON attribute
             const isCommon = /\bIS\s+COMMON\b/i.test(line);
             // Push program boundary for line-range tracking
-            programBoundaryStack.push({ name: m[1], startLine: lineNum, isCommon: isCommon || undefined });
+            programBoundaryStack.push({
+                name: m[1],
+                startLine: lineNum,
+                isCommon: isCommon || undefined,
+            });
             return;
         }
         const authorMatch = line.match(RE_AUTHOR);
@@ -1088,21 +1215,39 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
                 const afterUsing = fullSort.substring(usingIdx + 6);
                 const gIdx = afterUsing.toUpperCase().search(/\bGIVING\b/);
                 const usingText = gIdx >= 0 ? afterUsing.substring(0, gIdx) : afterUsing;
-                usingFiles.push(...usingText.trim().split(/\s+/).map(f => f.replace(/\.$/, '')).filter(f => /^[A-Z][A-Z0-9-]+$/i.test(f) && !SORT_CLAUSE_NOISE.has(f.toUpperCase())));
+                usingFiles.push(...usingText
+                    .trim()
+                    .split(/\s+/)
+                    .map((f) => f.replace(/\.$/, ''))
+                    .filter((f) => /^[A-Z][A-Z0-9-]+$/i.test(f) && !SORT_CLAUSE_NOISE.has(f.toUpperCase())));
             }
             if (givingIdx >= 0) {
                 const givingText = fullSort.substring(givingIdx + 7);
-                givingFiles.push(...givingText.trim().split(/\s+/).map(f => f.replace(/\.$/, '')).filter(f => /^[A-Z][A-Z0-9-]+$/i.test(f) && !SORT_CLAUSE_NOISE.has(f.toUpperCase())));
+                givingFiles.push(...givingText
+                    .trim()
+                    .split(/\s+/)
+                    .map((f) => f.replace(/\.$/, ''))
+                    .filter((f) => /^[A-Z][A-Z0-9-]+$/i.test(f) && !SORT_CLAUSE_NOISE.has(f.toUpperCase())));
             }
             // INPUT PROCEDURE IS / OUTPUT PROCEDURE IS → control-flow targets (like PERFORM)
             // Supports optional THRU/THROUGH range: INPUT PROCEDURE IS proc-start THRU proc-end
             const inputProcMatch = fullSort.match(/\bINPUT\s+PROCEDURE\s+(?:IS\s+)?([A-Z][A-Z0-9-]+)(?:\s+(?:THRU|THROUGH)\s+([A-Z][A-Z0-9-]+))?/i);
             const outputProcMatch = fullSort.match(/\bOUTPUT\s+PROCEDURE\s+(?:IS\s+)?([A-Z][A-Z0-9-]+)(?:\s+(?:THRU|THROUGH)\s+([A-Z][A-Z0-9-]+))?/i);
             if (inputProcMatch) {
-                result.performs.push({ caller: currentParagraph, target: inputProcMatch[1], thruTarget: inputProcMatch[2] || undefined, line: sortStartLine });
+                result.performs.push({
+                    caller: currentParagraph,
+                    target: inputProcMatch[1],
+                    thruTarget: inputProcMatch[2] || undefined,
+                    line: sortStartLine,
+                });
             }
             if (outputProcMatch) {
-                result.performs.push({ caller: currentParagraph, target: outputProcMatch[1], thruTarget: outputProcMatch[2] || undefined, line: sortStartLine });
+                result.performs.push({
+                    caller: currentParagraph,
+                    target: outputProcMatch[1],
+                    thruTarget: outputProcMatch[2] || undefined,
+                    line: sortStartLine,
+                });
             }
             result.sorts.push({ sortFile: smatch[1], usingFiles, givingFiles, line: sortStartLine });
         }
@@ -1129,9 +1274,12 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         const hasTallying = /\bTALLYING\b/i.test(text);
         const hasReplacing = /\bREPLACING\b/i.test(text);
         const hasConverting = /\bCONVERTING\b/i.test(text);
-        const form = hasConverting ? 'converting'
-            : hasTallying && hasReplacing ? 'tallying-replacing'
-                : hasTallying ? 'tallying'
+        const form = hasConverting
+            ? 'converting'
+            : hasTallying && hasReplacing
+                ? 'tallying-replacing'
+                : hasTallying
+                    ? 'tallying'
                     : 'replacing';
         result.inspects.push({
             inspectedField: fieldMatch[1],
@@ -1156,28 +1304,54 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
             const afterCall = text.substring(callMatch.index + callMatch[0].length);
             const usingMatch = afterCall.match(RE_USING_PARAMS);
             const parameters = usingMatch
-                ? usingMatch[1].split(/\bRETURNING\b/i)[0].trim().split(/\s+/)
-                    .filter(s => s.length > 0 && !CALL_USING_FILTER.has(s.toUpperCase()) && /^[A-Z][A-Z0-9-]+$/i.test(s))
+                ? usingMatch[1]
+                    .split(/\bRETURNING\b/i)[0]
+                    .trim()
+                    .split(/\s+/)
+                    .filter((s) => s.length > 0 &&
+                    !CALL_USING_FILTER.has(s.toUpperCase()) &&
+                    /^[A-Z][A-Z0-9-]+$/i.test(s))
                 : undefined;
             const retMatch = afterCall.match(/\bRETURNING\s+([A-Z][A-Z0-9-]+)/i);
             const returning = retMatch ? retMatch[1] : undefined;
-            result.calls.push({ target: callTarget, line: callAccumLine, isQuoted: true, parameters, returning });
+            result.calls.push({
+                target: callTarget,
+                line: callAccumLine,
+                isQuoted: true,
+                parameters,
+                returning,
+            });
         }
         // Extract dynamic CALLs from the full statement
         for (const dynCallMatch of text.matchAll(RE_CALL_DYNAMIC)) {
             const afterDynCall = text.substring(dynCallMatch.index + dynCallMatch[0].length);
             const dynUsingMatch = afterDynCall.match(RE_USING_PARAMS);
             const dynParameters = dynUsingMatch
-                ? dynUsingMatch[1].split(/\bRETURNING\b/i)[0].trim().split(/\s+/)
-                    .filter(s => s.length > 0 && !CALL_USING_FILTER.has(s.toUpperCase()) && /^[A-Z][A-Z0-9-]+$/i.test(s))
+                ? dynUsingMatch[1]
+                    .split(/\bRETURNING\b/i)[0]
+                    .trim()
+                    .split(/\s+/)
+                    .filter((s) => s.length > 0 &&
+                    !CALL_USING_FILTER.has(s.toUpperCase()) &&
+                    /^[A-Z][A-Z0-9-]+$/i.test(s))
                 : undefined;
             const dynRetMatch = afterDynCall.match(/\bRETURNING\s+([A-Z][A-Z0-9-]+)/i);
             const dynReturning = dynRetMatch ? dynRetMatch[1] : undefined;
-            result.calls.push({ target: dynCallMatch[1], line: callAccumLine, isQuoted: false, parameters: dynParameters, returning: dynReturning });
+            result.calls.push({
+                target: dynCallMatch[1],
+                line: callAccumLine,
+                isQuoted: false,
+                parameters: dynParameters,
+                returning: dynReturning,
+            });
         }
         // Extract CANCELs from within the CALL block (common in ON EXCEPTION handlers)
         for (const cancelMatch of text.matchAll(RE_CANCEL)) {
-            result.cancels.push({ target: cancelMatch[1] ?? cancelMatch[2], line: callAccumLine, isQuoted: true });
+            result.cancels.push({
+                target: cancelMatch[1] ?? cancelMatch[2],
+                line: callAccumLine,
+                isQuoted: true,
+            });
         }
         for (const dynCancelMatch of text.matchAll(RE_CANCEL_DYNAMIC)) {
             result.cancels.push({ target: dynCancelMatch[1], line: callAccumLine, isQuoted: false });
@@ -1311,8 +1485,11 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         if (pendingProcUsing) {
             const usingMatch = line.match(/\bUSING\s+([\s\S]*?)(?:\.|$)/i);
             if (usingMatch) {
-                const params = usingMatch[1].split(/\bRETURNING\b/i)[0].trim().split(/\s+/)
-                    .filter(s => s.length > 0 && !USING_KEYWORDS.has(s.toUpperCase()));
+                const params = usingMatch[1]
+                    .split(/\bRETURNING\b/i)[0]
+                    .trim()
+                    .split(/\s+/)
+                    .filter((s) => s.length > 0 && !USING_KEYWORDS.has(s.toUpperCase()));
                 result.procedureUsing = params;
                 const topProg = programBoundaryStack[programBoundaryStack.length - 1];
                 if (topProg)
@@ -1326,7 +1503,8 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         const secMatch = line.match(RE_PROC_SECTION);
         if (secMatch) {
             const name = secMatch[1];
-            if (!EXCLUDED_PARA_NAMES.has(name.toUpperCase()) && !name.toUpperCase().includes('DIVISION')) {
+            if (!EXCLUDED_PARA_NAMES.has(name.toUpperCase()) &&
+                !name.toUpperCase().includes('DIVISION')) {
                 result.sections.push({ name, line: lineNum });
                 // Don't set currentParagraph to section name — sections are Namespaces,
                 // not Functions. Setting it here would cause PERFORMs to be attributed
@@ -1344,7 +1522,10 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
             const leadingSpaces = line.match(/^(\s*)/)?.[1].length ?? 0;
             if (!isFreeFormat && leadingSpaces > 7)
                 return; // Area B — not a paragraph
-            if (!EXCLUDED_PARA_NAMES.has(name.toUpperCase()) && !name.toUpperCase().startsWith('END-') && name.toUpperCase() !== 'DIVISION' && name.toUpperCase() !== 'SECTION') {
+            if (!EXCLUDED_PARA_NAMES.has(name.toUpperCase()) &&
+                !name.toUpperCase().startsWith('END-') &&
+                name.toUpperCase() !== 'DIVISION' &&
+                name.toUpperCase() !== 'SECTION') {
                 result.paragraphs.push({ name, line: lineNum });
                 currentParagraph = name;
             }
@@ -1378,7 +1559,10 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
                 result.entryPoints.push({
                     name: entryName,
                     parameters: usingClause
-                        ? usingClause.trim().split(/\s+/).filter(s => s.length > 0 && !USING_KEYWORDS.has(s.toUpperCase()))
+                        ? usingClause
+                            .trim()
+                            .split(/\s+/)
+                            .filter((s) => s.length > 0 && !USING_KEYWORDS.has(s.toUpperCase()))
                         : [],
                     line: lineNum,
                 });
@@ -1392,7 +1576,7 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
                 const isCorresponding = !!moveMatch[1];
                 // MOVE CORRESPONDING is always single-target per COBOL standard
                 const targets = isCorresponding
-                    ? [moveMatch[3].replace(/\..*$/, '').trim().split(/\s+/)[0]].filter(t => /^[A-Z][A-Z0-9-]+$/i.test(t))
+                    ? [moveMatch[3].replace(/\..*$/, '').trim().split(/\s+/)[0]].filter((t) => /^[A-Z][A-Z0-9-]+$/i.test(t))
                     : extractMoveTargets(moveMatch[3]);
                 if (targets.length > 0) {
                     result.moves.push({
@@ -1408,7 +1592,10 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         // GO TO — control flow transfer (handles GO TO p1 p2 p3 DEPENDING ON x)
         const gotoMatch = line.match(RE_GOTO);
         if (gotoMatch) {
-            const targets = gotoMatch[1].trim().split(/\s+/).filter(t => /^[A-Z][A-Z0-9-]+$/i.test(t));
+            const targets = gotoMatch[1]
+                .trim()
+                .split(/\s+/)
+                .filter((t) => /^[A-Z][A-Z0-9-]+$/i.test(t));
             for (const target of targets) {
                 result.gotos.push({ caller: currentParagraph, target, line: lineNum });
             }
@@ -1436,11 +1623,12 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         // flush the INSPECT as-is and process the line normally.
         if (inspectAccum !== null) {
             const inspTrimmed = line.trimStart();
-            const inspLeading = (line.match(/^(\s*)/)?.[1].length ?? 0);
+            const inspLeading = line.match(/^(\s*)/)?.[1].length ?? 0;
             const inspIsAreaAPara = RE_PROC_PARAGRAPH.test(line) && (!isFreeFormat ? inspLeading <= 7 : false);
-            if (RE_PROC_SECTION.test(line) || inspIsAreaAPara
-                || RE_STATEMENT_VERB_START.test(inspTrimmed)
-                || /^CALL(?:\s|$)/i.test(inspTrimmed)) {
+            if (RE_PROC_SECTION.test(line) ||
+                inspIsAreaAPara ||
+                RE_STATEMENT_VERB_START.test(inspTrimmed) ||
+                /^CALL(?:\s|$)/i.test(inspTrimmed)) {
                 flushInspect();
                 // Fall through to process this line normally
             }
@@ -1469,7 +1657,11 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         }
         // CANCEL — program lifecycle (global matchAll captures multiple CANCELs on same line)
         for (const cancelMatch of line.matchAll(RE_CANCEL)) {
-            result.cancels.push({ target: cancelMatch[1] ?? cancelMatch[2], line: lineNum, isQuoted: true });
+            result.cancels.push({
+                target: cancelMatch[1] ?? cancelMatch[2],
+                line: lineNum,
+                isQuoted: true,
+            });
         }
         // Dynamic CANCEL — RE_CANCEL_DYNAMIC cannot match quoted targets, no dedup guard needed
         for (const dynCancelMatch of line.matchAll(RE_CANCEL_DYNAMIC)) {
@@ -1478,8 +1670,10 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         // SET statement (condition, index)
         const setTrueMatch = line.match(RE_SET_TO_TRUE);
         if (setTrueMatch) {
-            const targets = setTrueMatch[1].trim().split(/\s+/)
-                .filter(t => /^[A-Z][A-Z0-9-]+$/i.test(t) && t.toUpperCase() !== 'OF');
+            const targets = setTrueMatch[1]
+                .trim()
+                .split(/\s+/)
+                .filter((t) => /^[A-Z][A-Z0-9-]+$/i.test(t) && t.toUpperCase() !== 'OF');
             if (targets.length > 0) {
                 result.sets.push({ targets, form: 'to-true', line: lineNum, caller: currentParagraph });
             }
@@ -1487,20 +1681,32 @@ export function extractCobolSymbolsWithRegex(content, _filePath) {
         else {
             const setIdxMatch = line.match(RE_SET_INDEX);
             if (setIdxMatch) {
-                const targets = setIdxMatch[1].trim().split(/\s+/)
-                    .filter(t => /^[A-Z][A-Z0-9-]+$/i.test(t));
+                const targets = setIdxMatch[1]
+                    .trim()
+                    .split(/\s+/)
+                    .filter((t) => /^[A-Z][A-Z0-9-]+$/i.test(t));
                 const mode = setIdxMatch[2].toUpperCase();
-                const form = mode === 'TO' ? 'to-value'
-                    : mode.startsWith('UP') ? 'up-by'
+                const form = mode === 'TO'
+                    ? 'to-value'
+                    : mode.startsWith('UP')
+                        ? 'up-by'
                         : 'down-by';
-                result.sets.push({ targets, form, value: setIdxMatch[3], line: lineNum, caller: currentParagraph });
+                result.sets.push({
+                    targets,
+                    form,
+                    value: setIdxMatch[3],
+                    line: lineNum,
+                    caller: currentParagraph,
+                });
             }
         }
         // INITIALIZE — data reset (multi-target: INITIALIZE WS-A WS-B WS-C.)
         const initMatch = line.match(RE_INITIALIZE);
         if (initMatch) {
-            const targets = initMatch[1].trim().split(/\s+/)
-                .filter(t => /^[A-Z][A-Z0-9-]+$/i.test(t) && !INITIALIZE_CLAUSE_KEYWORDS.has(t.toUpperCase()));
+            const targets = initMatch[1]
+                .trim()
+                .split(/\s+/)
+                .filter((t) => /^[A-Z][A-Z0-9-]+$/i.test(t) && !INITIALIZE_CLAUSE_KEYWORDS.has(t.toUpperCase()));
             for (const target of targets) {
                 result.initializes.push({ target, line: lineNum, caller: currentParagraph });
             }

package/dist/core/ingestion/cobol/jcl-parser.js

@@ -135,7 +135,7 @@ export function parseJcl(content, filePath) {
         // JCLLIB ORDER=
         const jcllibMatch = text.match(JCLLIB_RE);
         if (jcllibMatch) {
-            const libs = jcllibMatch[1].split(',').map(s => s.trim().replace(/'/g, ''));
+            const libs = jcllibMatch[1].split(',').map((s) => s.trim().replace(/'/g, ''));
             results.jcllib.push({ order: libs, line: lineNum });
             continue;
         }

package/dist/core/ingestion/cobol/jcl-processor.js

@@ -32,7 +32,7 @@ export function processJclFiles(graph, jclPaths, jclContents) {
     let programLinks = 0;
     // Collect all Module names for step -> program linking
     const moduleNames = new Map(); // uppercase name -> node id
-    graph.forEachNode(node => {
+    graph.forEachNode((node) => {
         if (node.label === 'Module') {
             const nodeName = node.properties.name;
             if (typeof nodeName === 'string') {