How ArchUnit sees your system.

excludes = _resolve_exclude_patterns(project_path, patterns)
py_files = _find_python_files(project_path, excludes)
known_files = {_normalize(path) for path in py_files}

for file_path in py_files:
    edges.append(Edge(file_path, file_path, external=False))
    with open(file_path, "r", encoding="utf-8", errors="replace") as f:
        source = f.read()
    tree = ast.parse(source, filename=file_path)

    for node in ast.walk(tree):
        located = classify_import(node)
        if located is None:
            continue
        for target, external in _resolve_import_targets(
            located, file_path, project_path
        ):
            if external or target in known_files:
                edges.append(Edge(
                    source=_normalize(file_path),
                    target=target,
                    external=external,
                    import_kinds=_edge_import_kinds(located),
                ))

return _merge_edges(edges)

const contexts: ts.ParsedCommandLine[] = [];
const visited = new Set<string>();

function visitConfig(configPath: string) {
  const identity = path.resolve(configPath);
  if (visited.has(identity)) return;
  visited.add(identity);

  const source = ts.readConfigFile(identity, ts.sys.readFile);
  const parsed = ts.parseJsonConfigFileContent(
    source.config, ts.sys, path.dirname(identity), {}, identity
  );
  contexts.push(parsed);

  for (const ref of parsed.projectReferences ?? []) {
    visitConfig(ts.resolveProjectReferencePath(ref));
  }
}

visitConfig("tsconfig.json");
const options = contexts[0].options;
const host = ts.createCompilerHost(options);
const rootNames = [...new Set(contexts.flatMap(c => c.fileNames))];
const program = ts.createProgram({ rootNames, options, host });

for (const sourceFile of program.getSourceFiles()) {
  ts.forEachChild(sourceFile, node => {
    if (!ts.isImportDeclaration(node)) return;
    const moduleName = (node.moduleSpecifier as { text?: string }).text;
    if (!moduleName) return;
    const resolved = ts.resolveModuleName(
      moduleName, sourceFile.fileName, options, host
    ).resolvedModule;
    if (!resolved) return;
    imports.push({
      source: normalize(sourceFile.fileName),
      target: normalize(resolved.resolvedFileName),
      external: resolved.isExternalLibraryImport ?? false,
      importKinds: determineImportKinds(node),
    });
  });
}