• • Exposed previously hidden nodes by replacing anonymous node types with named fields, enabling precise code mapping.
  • Changed program_name in the identification_division to a named field (prg_name) and made it use the non-anonymous WORD type.

// Before
    identification_division: $ => seq(
     $._IDENTIFICATION, $._DIVISION, '.',
     optional(
     seq($._PROGRAM_ID, '.',
     $.program_name,
     …
    ),
    program_name: $ => choice( $._WORD, $._LITERAL ),
// After
   identification_division: $ => seq(
   $._IDENTIFICATION, $._DIVISION, '.',
   optional(
   seq($._PROGRAM_ID, '.',
   field('prg_name', $.program_name),
   …
   ),
   program_name: $ => choice( $.WORD, $.LITERAL ),

• • Updated section_header and paragraph_header to use $.WORD instead of the anonymous $._WORD, ensuring these nodes are visible to tags queries.

// Before
    section_header: $ => seq(
      field('name', choice($._WORD, $.integer)),
      ...
    ),
    paragraph_header: $ => seq(
      field('name', choice($._WORD, $.integer)),
      '.'
    ),
// After
    section_header: $ => seq(
      field('name', choice($.WORD, $.integer)),  
      ...
    ),
    paragraph_header: $ => seq(
      field('name', choice($.WORD, $.integer)), 
      '.'
    ),

• • To build Python bindings for the modified COBOL grammar, we first initialized the local Tree-sitter configuration to enable Python support, then regenerated the parser with ABI version 14 (since the official Tree-sitter project is still on version 14, not 15), built the language bindings, and finally installed the resulting Python package in the target environment where aider is installed.

cd <Cloning directory>
tree-sitter init-config          # Set up Tree-sitter CLI configuration for bindings
tree-sitter generate --abi 14   # Generate the parser using ABI version 14
tree-sitter build              # Build language bindings, including Python
pip install .                 # Install the Python package of the grammar

• • Created a tags.scm file aligned with the updated grammar, enabling extraction of key elements for repository mapping.

(identification_division
  prg_name: (_) @name.definition.program) @definition.program

(file_description_entry 
  (WORD) @name.definition.filename) @definition.filename

(
  section_header
    name: (_) @name.definition.section
) @definition.section

(
  paragraph_header
    name: (_) @name.definition.paragraph
) @definition.paragraph

(perform_procedure (_) @name.reference.paragraph) @reference.call

2️⃣ Register COBOL File Extensions in Grep-AST

• • In your Aider environment, edit: .../lib/pythonx.x/site-packages/grep-ast/parsers.py
  • Extend the PARSERS dictionary inside the USING_TSL_PACK block to associate COBOL file extensions with the "cobol" language:

# Before
if USING_TSL_PACK:
    # Replace the PARSERS dictionary with a comprehensive mapping based on the language pack
    PARSERS = { ....
        
        # C
        ".c": "c",
        ".h": "c",
              
   }

#After
if USING_TSL_PACK:
    # Replace the PARSERS dictionary with a comprehensive mapping based on the language pack
    PARSERS = { .....
        
        # C
        ".c": "c",
        ".h": "c",
        # Add COBOL file extension
        ".cob": "cobol",
        ".cbl": "cobol",
        ".cpy": "cobol",
        ".COB": "cobol",
        ".CBL": "cobol",
        ".CPY": "cobol",
        
   }

• • The grep-ast module fetches the appropriate parser for each supported language using the tree-sitter-language-pack. To enable COBOL support, make the following changes, open: lib/pythonx.x/site-packages/tree-sitter-language-pack/__init__.py
  • Add "cobol" to the SupportedLanguage literal
  • In the function that loads language bindings (get_binding), add explicit logic to import our custom COBOL parser:

# In get binding function, we need to explicitly mention to import cobol when the language name is cobol
def get_binding(language_name: SupportedLanguage) -> object:
   
    if language_name == "cobol":                 
        import tree_sitter_tree_sitter_cobol     # Use your actual package name if different
        return tree_sitter_tree_sitter_cobol.language() 

Generating COBOL Code with Aider:

• • We asked Aider to generate a COBOL program (demo.cbl) designed to read inputs, perform addition, and conditionally call multiplication or division procedures based on the result. Aider created the source file and committed the code, as shown in the output. The initial COBOL program followed standard structure, including the IDENTIFICATION DIVISION, DATA DIVISION, and the required procedures.

• • To demonstrate Aider’s linting capabilities, we intentionally introduced a typo in IDENTIFICATION DIVISION and an indentation error in the DATA DIVISION. When linting was run, Aider first flagged the keyword typo; after correction, it then detected the indentation issue, showing that errors are caught and reported sequentially, with clear guidance for each fix.

• • The structure of the COBOL program is mapped using the custom cobol-tags.scm file defined earlier. This mapping enables Aider to extract program entities, such as program names, sections, and procedures directly from the parse tree, allowing for efficient codebase navigation and analysis.

With these features in place, Aider not only automates COBOL code generation but also provides robust linting and precise repo mapping based on our custom grammar and tags configuration. This ensures reliable error detection and a clear understanding of code structure throughout the development workflow.