Function execute

ui/src/components/pipeline/stages/processing.ts:49–245

(
  input: ScanResult,
  ctx: PipelineContext,
)

import type { Registries, CallInfo } from '../parser/callResolver';

export function* execute(
  input: ScanResult,
  ctx: PipelineContext,
): Generator<PipelineEvent, ProcessingOutput> {
  const { parseableFiles, repoId, knownPaths, pathToFileId, goModulePath } =
    input;
  const total = parseableFiles.length;

  yield {
    kind: 'stage_start',
    phase: 'processing',
    message: `Processing ${total} files`,
  };

  // Initialize registries
  const registries: Registries = {
    nameRegistry: new Map(),
    fileRegistry: new Map(),
    classRegistry: new Map(),
    importRegistry: new Map(),
  };
  const allCallInfo: CallInfo[] = [];
  const emittedNodeIds = new Set<string>();

  // Copy package nodes from scanning (will accumulate more from imports)
  const packageNodes = new Map(input.packageNodes);

  const structureNodes: GraphNode[] = [
    input.repoNode,
    ...input.dirNodes.values(),
    ...input.fileNodes,
    ...input.packageNodes.values(),
  ];
  let totalNodes = structureNodes.length;
  let totalRels = input.structureRels.length + input.dependencyRels.length;
  let filesProcessed = 0;
  let classesExtracted = 0;
  let functionsExtracted = 0;
  const errors: string[] = [];

  for (let i = 0; i < parseableFiles.length; i++) {
    if (ctx.cancelled) break;

    const file = parseableFiles[i];
    const ext = getExtension(file.path);
    const language = detectLanguage(ext);
    const fileId = `${repoId}/${file.path}`;

    if (!language) {
      filesProcessed++;
      continue;
    }

    const parser = getParserForLanguage(language, ext);
    const extractor = getExtractor(language);

    if (!parser || !extractor) {
      filesProcessed++;