Function parseFile

src/core/treeSitter/parseFile.ts:43–123

(
  fileContent: string,
  filePath: string,
  config: RepomixConfigMerged,
)

// whole pack. The success path is fully wrapped so a partially-built result is
// never returned on error.
export const parseFile = async (
  fileContent: string,
  filePath: string,
  config: RepomixConfigMerged,
): Promise<string | undefined> => {
  // Split the file content into individual lines
  const lines = fileContent.split('\n');

  try {
    const languageParser = await getLanguageParserSingleton();

    const lang: SupportedLang | undefined = languageParser.guessTheLang(filePath);
    if (lang === undefined) {
      // Language not supported: fall back to uncompressed content quietly.
      return undefined;
    }

    const query = await languageParser.getQueryForLang(lang);
    const parser = await languageParser.getParserForLang(lang);
    const processedChunks = new Set<string>();
    const capturedChunks: CapturedChunk[] = [];

    // Parse the file content into an Abstract Syntax Tree (AST)
    const tree = parser.parse(fileContent);
    if (!tree) {
      logger.debug(`Failed to parse file: ${filePath}`);
      return undefined;
    }

    // Get the appropriate parse strategy for the language
    const parseStrategy = await languageParser.getStrategyForLang(lang);

    // Create parse context
    const context: ParseContext = {
      fileContent,
      lines,
      tree,
      query,
      config,
    };

    // Apply the query to the AST and get the captures
    const captures = query.captures(tree.rootNode);

    // Sort captures by their start position
    captures.sort((a, b) => a.node.startPosition.row - b.node.startPosition.row);

    for (const capture of captures) {
      const capturedChunkContent = parseStrategy.parseCapture(capture, lines, processedChunks, context);
      if (capturedChunkContent !== null) {
        capturedChunks.push({
          content: capturedChunkContent.trim(),
          startRow: capture.node.startPosition.row,
          endRow: capture.node.endPosition.row,
        });
      }
    }