Function astChunkFile

src/context/ast-chunk.ts:118–268

(rel: string, content: string, maxLines = 80)

 * `maxLines` caps a single chunk; larger declarations are line-split.
 */
export async function astChunkFile(rel: string, content: string, maxLines = 80): Promise<Chunk[]> {
  const lang = langForFile(rel);
  if (!lang) return lineChunk(rel, content);
  const boundary = BOUNDARY_TYPES[lang];
  if (!boundary) return lineChunk(rel, content);

  let parser;
  try {
    parser = await getParser(lang);
  } catch {
    return lineChunk(rel, content);
  }
  if (!parser) return lineChunk(rel, content);

  let tree;
  try {
    tree = parser.parser.parse(content);
  } catch {
    return lineChunk(rel, content);
  }

  const lines = content.split('\n');
  const root = tree.rootNode;
  const chunks: Chunk[] = [];
  const boundaries: Array<{ startLine: number; endLine: number; symbol?: string; qualifiedSymbol?: string }> = [];

  // Container node types whose children we descend into to chunk members
  // (methods, nested functions, nested classes) as their own units.
  //   - JS/TS: class_declaration, class_body
  //   - Python: class_definition (+ block body)
  //   - PHP: class_declaration, trait/interface declaration
  //   - Rust: impl_item, trait_item, mod_item (bodies are declaration_list)
  //   - Go: a struct is type_declaration but holds NO methods (methods are
  //     top-level funcs with receivers), so Go intentionally has no container
  //     to descend — its functions are already top-level boundaries.
  const CONTAINER_RE = /^(class_declaration|abstract_class_declaration|class_definition|class_specifier|class_body|class|interface_declaration|trait_declaration|trait_item|impl_item|mod_item|module|namespace_definition|namespace|object|enum_declaration|enum_item|declaration_list)$/;
  // Body node types that hold a container's members.
  const BODY_RE = /^(body|class_body|declaration_list|field_declaration_list|enum_body|block|impl_item|trait_item)$/;

  /**
   * Recursively collect chunk boundaries.
   *
   * Strategy (depth-unbounded, but cost-bounded by maxLines):
   *  - A boundary node that fits in maxLines becomes ONE chunk, with its full
   *    text (decorators included — see decorator handling below).
   *  - A boundary node that is a CONTAINER and is LARGER than maxLines is split:
   *    we don't emit the whole container, we descend into its body and chunk each
   *    member (method / nested function / nested class) separately, qualifying
   *    each member's symbol with the container name (e.g. "UserService.login").
   *    This is what fixes deeply-nested React/Django/FastAPI code: a 400-line
   *    class no longer becomes one giant chunk or gets cut mid-method.
   *  - Decorators (Python @decorator, TS @Component) are part of the
   *    decorated_definition / are preceding siblings; tree-sitter's
   *    decorated_definition node already spans them, and for TS the decorators
   *    are children of the class/method node, so the node's start..end already
   *    includes them. We therefore chunk on the OUTERMOST node so the decorator
   *    travels with the thing it decorates.
   */