pull-request-split-advisor 3.1.2

package/dist/core/commit-planner.js

@@ -0,0 +1,273 @@
+/**
+ * commit-planner.ts — Generación del plan de commits para una rama.
+ *
+ * A partir de los bloques asignados a una rama produce una secuencia ordenada
+ * de {@link CommitPlan}: cada elemento representa un commit con sus archivos,
+ * mensaje sugerido y metadatos (type, scope, subject).
+ *
+ * ### Algoritmo de agrupación
+ * 1. Los bloques se ordenan: prioridad asc → depScore desc → indivisibles primero → más líneas primero.
+ * 2. Bloques **indivisibles** o **medianos** (`lines > mediumFileThreshold`) van
+ *    siempre en su propio commit (`mustIsolate = true`).
+ * 3. Los demás bloques se acumulan en el commit actual hasta superar
+ *    `maxLinesPerCommitIdeal` o `maxFilesPerCommit`; entonces se flush y se empieza uno nuevo.
+ * 4. Al terminar el bucle, el grupo pendiente se flushea.
+ *
+ * ### Inferencia del mensaje de commit
+ * El tipo, scope y subject se infieren heurísticamente a partir de los nombres y
+ * rutas de los archivos del commit. Si `enrichCommitTickets` se ejecuta después,
+ * el ticket se incrusta en `suggestedMessage`.
+ *
+ * @module
+ */
+import { basename, dirname } from "node:path";
+import { normalizePathValue } from "../shared/utils.js";
+// ---------------------------------------------------------------------------
+// Commit type / scope / subject detection
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Inferencia de tipo, scope y subject del commit
+// ---------------------------------------------------------------------------
+/**
+ * Infiere el tipo Conventional Commits a partir de los patrones de ruta y nombre de los archivos.
+ *
+ * Tipos soportados (en orden de prioridad):
+ * 1. `ci`       — archivos de CI/CD o DevSecOps
+ * 2. `docs`     — todos los archivos son documentación
+ * 3. `test`     — todos los archivos son pruebas
+ * 4. `style`    — todos son archivos de formato/linters (CSS, .eslintrc, .prettierrc…)
+ * 5. `perf`     — archivos con patrones de rendimiento/optimización
+ * 6. `refactor` — tipos, interfaces, schemas, DTOs, modelos
+ * 7. `fix`      — archivos con patrones de corrección de errores (bugfix/hotfix)
+ * 8. `chore`    — configuraciones, dependencias, YAML/TOML no-CI
+ * 9. `feat`     — fallback para todo lo demás
+ *
+ * @param files - Rutas de los archivos del commit.
+ */
+function detectCommitType(files) {
+    const lower = files.map((f) => f.toLowerCase());
+    // ci: integración continua / entrega continua / DevSecOps
+    if (lower.some((f) => /(?:^|\/)\.github\/workflows\//.test(f) ||
+        /(?:^|\/)\.gitlab-ci\.ya?ml$/.test(f) ||
+        /(?:^|\/)[jJ]enkinsfile(\.[^/]*)?$/.test(f) ||
+        /(?:^|\/)\.circleci\//.test(f) ||
+        /(?:^|\/)\.travis\.ya?ml$/.test(f) ||
+        /(?:^|\/)azure-pipelines\.ya?ml$/.test(f) ||
+        /(?:^|\/)bitbucket-pipelines\.ya?ml$/.test(f) ||
+        /(?:^|\/)[dD]ockerfile(\.[^/]*)?$/.test(f) ||
+        /(?:^|\/)docker-compose[^/]*\.ya?ml$/.test(f))) {
+        return "ci";
+    }
+    // docs: todos los archivos son documentación
+    if (lower.every((f) => /(^|\/)(docs|doc)(\/|$)|(^|\/)readme(\.[^/]*)?$|(^|\/)changelog(\.[^/]*)?$|\.md$|\.adoc$|\.rst$/.test(f))) {
+        return "docs";
+    }
+    // test: todos los archivos son pruebas unitarias
+    if (lower.every((f) => /(^|\/)(__tests__|tests|test)(\/|$)|(\.spec\.|\.test\.)/.test(f))) {
+        return "test";
+    }
+    // style: todos son archivos de formato o herramientas de estilo (linters, formateadores, CSS)
+    if (lower.every((f) => /\.(css|scss|sass|less)$/.test(f) ||
+        /(?:^|\/)\.eslintrc[^/]*$/.test(f) ||
+        /(?:^|\/)\.prettierrc[^/]*$/.test(f) ||
+        /(?:^|\/)\.editorconfig$/.test(f) ||
+        /(?:^|\/)\.stylelintrc[^/]*$/.test(f))) {
+        return "style";
+    }
+    // perf: mejoras de rendimiento sin cambios funcionales
+    if (lower.some((f) => /\b(perf|performance|optim|optimize|cache|memo|memoize)\b/.test(f))) {
+        return "perf";
+    }
+    // refactor: reestructuración de código sin nuevas funcionalidades ni correcciones
+    if (lower.some((f) => /\b(type|types|interface|interfaces|schema|schemas|dto|dtos|model|models)\b/.test(f))) {
+        return "refactor";
+    }
+    // fix: corrección de errores (aplica también a ramas bugfix y hotfix)
+    if (lower.some((f) => /\b(fix|bug|hotfix|patch)\b/.test(f))) {
+        return "fix";
+    }
+    // chore: configuraciones, dependencias externas, empaquetadores, migraciones
+    // .json solo es chore cuando es un archivo de configuración conocido; los .json en src/ pueden ser feat.
+    if (lower.some((f) => /(^|\/)(config|configs|settings)(\/|$)|\.ya?ml$|\.toml$/.test(f) ||
+        /(?:^|\/)(?:package|tsconfig[^/]*|\.babelrc|[a-z.]+\.config)\.json$/.test(f))) {
+        return "chore";
+    }
+    return "feat";
+}
+/**
+ * Infiere el scope del commit a partir del directorio más frecuente entre los archivos.
+ *
+ * Ignora directorios genéricos (`src`, `lib`, `app`, `dist`) que no aportan
+ * contexto útil. Si todos los archivos están en directorios genéricos, usa el
+ * nombre base del primer archivo como fallback.
+ *
+ * @param files - Rutas de los archivos del commit.
+ */
+function detectCommitScope(files) {
+    const normalized = files.map((f) => normalizePathValue(f).toLowerCase());
+    // Derivar scope del directorio padre más frecuente (genérico para cualquier proyecto)
+    const dirs = normalized
+        .map((f) => dirname(f))
+        .filter((d) => d && d !== "." && d !== "/")
+        .map((d) => d.split("/").pop() ?? d);
+    if (dirs.length) {
+        const counts = new Map();
+        for (const dir of dirs)
+            counts.set(dir, (counts.get(dir) ?? 0) + 1);
+        const top = [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+        // Excluir carpetas genéricas que no aportan contexto
+        const generic = new Set(["src", "lib", "app", "dist"]);
+        if (top && !generic.has(top))
+            return top;
+    }
+    // Fallback: nombre base del primer archivo
+    const baseNames = normalized
+        .map((f) => basename(f).replace(/\.[^.]+$/, ""))
+        .filter(Boolean);
+    if (baseNames.length)
+        return baseNames[0];
+    return "core";
+}
+/**
+ * Genera un subject breve y legible para el commit a partir del tipo y los archivos.
+ *
+ * Las descripciones están en español para coincidir con la UI del proyecto.
+ * Para commits de tipo `feat` con un solo archivo, incluye el nombre del archivo
+ * para dar más contexto. El parámetro `_scope` está reservado para futura
+ * personalización por scope.
+ *
+ * @param files   - Rutas de los archivos del commit.
+ * @param type    - Tipo Conventional Commits ya inferido.
+ * @param _scope  - Scope ya inferido (no usado actualmente, reservado).
+ */
+function detectCommitSubject(files, type, _scope) {
+    const lower = files.map((f) => f.toLowerCase());
+    // Sujetos basados en el tipo (siempre aplicables, independientes del proyecto)
+    if (type === "ci")
+        return "actualizar configuracion de CI/CD";
+    if (type === "docs")
+        return "actualizar documentacion relacionada";
+    if (type === "test")
+        return "agregar o corregir pruebas unitarias";
+    if (type === "style")
+        return "aplicar formato y estilo de codigo";
+    if (type === "perf")
+        return "mejorar rendimiento de la aplicacion";
+    if (type === "fix")
+        return "corregir comportamiento incorrecto";
+    if (type === "revert")
+        return "revertir cambios anteriores";
+    if (type === "refactor")
+        return "refactorizar sin cambios de negocio";
+    if (type === "chore") {
+        if (lower.some((f) => /\.(ya?ml|toml)$/.test(f)))
+            return "actualizar archivos de configuracion";
+        return "actualizar dependencias o configuracion";
+    }
+    // Sujeto basado en extensión / tipo de archivo
+    if (lower.some((f) => f.endsWith(".html") || f.endsWith(".css"))) {
+        return "actualizar vistas y estilos";
+    }
+    // Fallback genérico
+    return files.length === 1
+        ? `actualizar ${basename(files[0]).toLowerCase()}`
+        : "actualizar archivos relacionados";
+}
+/**
+ * Combina las tres funciones de detección en un solo objeto de partes del título.
+ * Mantiene el orden de llamadas estándar para evitar repetirlo en cada sitio de uso.
+ */
+export function buildCommitTitleParts(files) {
+    const suggestedType = detectCommitType(files);
+    const suggestedScope = detectCommitScope(files);
+    const suggestedSubject = detectCommitSubject(files, suggestedType, suggestedScope);
+    return { suggestedType, suggestedScope, suggestedSubject };
+}
+/**
+ * Construye el mensaje de commit en formato Conventional Commits:
+ * `type(scope): [ticket] subject`.
+ *
+ * @param suggestedType    - Tipo inferido (feat, fix, chore, etc.).
+ * @param suggestedScope   - Scope inferido del directorio/nombre de archivo.
+ * @param suggestedSubject - Descripción breve de los cambios.
+ * @param ticketCode       - Prefijo de ticket opcional (p.ej. "ABC-123").
+ */
+export function buildSuggestedMessage(suggestedType, suggestedScope, suggestedSubject, ticketCode) {
+    const ticketPart = ticketCode ? `${ticketCode} ` : "";
+    return `${suggestedType}(${suggestedScope}): ${ticketPart}${suggestedSubject}`;
+}
+// ---------------------------------------------------------------------------
+// Public
+// ---------------------------------------------------------------------------
+/**
+ * Genera el plan de commits para un conjunto de bloques.
+ *
+ * Ordena los bloques por prioridad (asc), luego por depScore (desc), luego por
+ * divisibilidad y por tamaño, y los agrupa respetando `config.maxFilesPerCommit`
+ * y `config.maxLinesPerCommitIdeal`. Para cada grupo infiere type, scope y
+ * subject a partir de los nombres y rutas de los archivos.
+ *
+ * @param blocks - Bloques a incluir en el plan.
+ * @param config - Configuración activa del proyecto.
+ * @returns      Array de {@link CommitPlan} en el orden de commit sugerido.
+ */
+export function buildCommitPlan(blocks, config) {
+    // Si la rama tiene contexto de nomenclatura, usamos su ticket como prefijo automático.
+    const autoTicket = config.branchNamingContext
+        ? `${config.branchNamingContext.teamCode}-${config.branchNamingContext.storyNumber}`
+        : undefined;
+    const ordered = [...blocks].sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        if (a.depScore !== b.depScore)
+            return b.depScore - a.depScore;
+        if (a.divisible !== b.divisible)
+            return a.divisible ? 1 : -1;
+        return b.lines - a.lines;
+    });
+    const commits = [];
+    let currentFiles = [];
+    let currentLines = 0;
+    let index = 1;
+    const pushCurrent = () => {
+        if (!currentFiles.length)
+            return;
+        const titleParts = buildCommitTitleParts(currentFiles);
+        commits.push({
+            index,
+            files: [...currentFiles],
+            totalLines: currentLines,
+            ...titleParts,
+            suggestedMessage: buildSuggestedMessage(titleParts.suggestedType, titleParts.suggestedScope, titleParts.suggestedSubject, autoTicket)
+        });
+        index += 1;
+        currentFiles = [];
+        currentLines = 0;
+    };
+    for (const block of ordered) {
+        const mustIsolate = !block.divisible || block.lines > config.mediumFileThreshold;
+        if (mustIsolate) {
+            pushCurrent();
+            const titleParts = buildCommitTitleParts(block.files);
+            commits.push({
+                index,
+                files: [...block.files],
+                totalLines: block.lines,
+                ...titleParts,
+                suggestedMessage: buildSuggestedMessage(titleParts.suggestedType, titleParts.suggestedScope, titleParts.suggestedSubject, autoTicket)
+            });
+            index += 1;
+            continue;
+        }
+        const projectedLines = currentLines + block.lines;
+        const projectedFiles = currentFiles.length + block.files.length;
+        if (projectedLines > config.maxLinesPerCommitIdeal ||
+            projectedFiles > config.maxFilesPerCommit) {
+            pushCurrent();
+        }
+        currentFiles.push(...block.files);
+        currentLines += block.lines;
+    }
+    pushCurrent();
+    return commits;
+}

package/dist/core/dependency.js

@@ -0,0 +1,284 @@
+/**
+ * dependency.ts — Detección heurística de dependencias entre archivos cambiados.
+ *
+ * Analiza las sentencias de importación de los archivos modificados para
+ * construir un grafo de aristas `{ from, to }` donde ambos nodos pertenecen
+ * al conjunto de archivos cambiados. Las importaciones hacia código no tocado
+ * se ignoran (no aportan información útil para la división del PR).
+ *
+ * ### Lenguajes soportados
+ * - **TypeScript / JavaScript** (`.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, `.cjs`):
+ *   detecta `import … from`, `require()` e `import()` dinámico.
+ *   Resuelve rutas relativas probando las extensiones más comunes y los
+ *   patrones de módulo índice (`index.ts`, `index.js`, etc.).
+ * - **Python** (`.py`): detecta `import …` y `from … import`.
+ *   Soporta imports relativos (`from . import …`) y absolutos.
+ * - **Java** (`.java`): detecta `import com.package.ClassName;`.
+ *   Construye el conjunto de archivos `.java` del repositorio una sola vez
+ *   (con `git ls-files -- '*.java'`) para resolver en O(1) sin `find` por clase.
+ *
+ * ### Cachés de rendimiento
+ * - `_fileContentCache`: evita releer o ejecutar `git show HEAD:<archivo>` más de
+ *   una vez por archivo en un mismo análisis. Se limpia al inicio de cada llamada
+ *   a `buildDependencyEdges` para garantizar datos frescos.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, extname } from "node:path";
+import { q, shSafe } from "../git/git.js";
+import { normalizePathValue, fileExistsInRepoOrFs } from "../shared/utils.js";
+// ---------------------------------------------------------------------------
+// Detección de lenguaje
+// ---------------------------------------------------------------------------
+/**
+ * Clasifica un archivo por su lenguaje de programación basándose en la extensión.
+ * Los lenguajes no reconocidos devuelven `"other"` y no se analiza su contenido.
+ */
+function detectLanguage(file) {
+    const ext = extname(file).toLowerCase();
+    if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext))
+        return "js";
+    if (ext === ".py")
+        return "py";
+    if (ext === ".java")
+        return "java";
+    return "other";
+}
+// ---------------------------------------------------------------------------
+// Lectura de archivos con caché en memoria
+// ---------------------------------------------------------------------------
+/** Caché de contenido por ruta para evitar releer o ejecutar `git show` múltiples veces. */
+const _fileContentCache = new Map();
+/**
+ * Limpia la caché de contenido de archivos.
+ * Útil para garantizar datos frescos entre análisis sucesivos en el mismo proceso (tests, llamadas encadenadas).
+ */
+export function clearDependencyCache() {
+    _fileContentCache.clear();
+}
+/**
+ * Lee el contenido de un archivo para parsear sus imports.
+ *
+ * Estrategia:
+ * 1. Si el archivo existe en disco (working tree), lo lee directamente.
+ * 2. Si fue eliminado o no está en disco, intenta obtenerlo desde `git show HEAD:<ruta>`.
+ *    Esto permite detectar dependencias de archivos que han sido borrados pero
+ *    aún están en el último commit.
+ * 3. El resultado se cachéa para evitar releer el mismo archivo en el mismo análisis.
+ *
+ * @param file - Ruta relativa del archivo a leer.
+ * @returns    Contenido del archivo como texto, o `""` si no se puede obtener.
+ */
+function readFileForParsing(file) {
+    const cached = _fileContentCache.get(file);
+    if (cached !== undefined)
+        return cached;
+    let content;
+    try {
+        content = readFileSync(file, "utf8");
+    }
+    catch {
+        content = shSafe(`git show HEAD:${q(file)}`);
+    }
+    _fileContentCache.set(file, content);
+    return content;
+}
+// ---------------------------------------------------------------------------
+// Resolvedores de rutas de import por lenguaje
+// ---------------------------------------------------------------------------
+/**
+ * Resuelve un import relativo JS/TS a una ruta de archivo concreta.
+ *
+ * Solo procesa imports relativos (que comienzan por `"."`). Los imports de
+ * módulos de node_modules o paths absolutos se ignoran porque no pertenecerán
+ * al conjunto de archivos cambiados.
+ *
+ * Prueba en orden: la ruta tal cual, + las extensiones `.ts`, `.tsx`, `.js`, `.jsx`,
+ * y los variantes `/index.<ext>`. Devuelve la primera que exista en disco o en git.
+ *
+ * @param importer - Ruta del archivo que contiene el import.
+ * @param imp      - Valor del import (ej. `"./utils"`, `"../core/service"`).
+ * @returns        Ruta resuelta o `null` si no se encuentra.
+ */
+function resolveJsImport(importer, imp) {
+    if (!imp.startsWith("."))
+        return null;
+    const importerDir = dirname(importer);
+    const candidate = normalizePathValue(`${importerDir}/${imp}`);
+    const variants = [
+        candidate,
+        `${candidate}.ts`,
+        `${candidate}.tsx`,
+        `${candidate}.js`,
+        `${candidate}.jsx`,
+        `${candidate}.mjs`,
+        `${candidate}.cjs`,
+        `${candidate}/index.ts`,
+        `${candidate}/index.tsx`,
+        `${candidate}/index.js`,
+        `${candidate}/index.jsx`,
+        `${candidate}/index.mjs`,
+        `${candidate}/index.cjs`
+    ];
+    for (const v of variants) {
+        if (fileExistsInRepoOrFs(v))
+            return v;
+    }
+    return null;
+}
+/**
+ * Resuelve un import Python (relativo o absoluto) a una ruta de archivo.
+ *
+ * - Imports relativos (`from . import`, `from .utils import`): usa el directorio
+ *   del importador como base y construye la ruta.
+ * - Imports absolutos (`import os.path`): convierte los puntos del paquete a `/`.
+ * - Prueba tanto `<ruta>.py` como `<ruta>/__init__.py` para soportar paquetes.
+ *
+ * @param importer - Ruta del archivo Python que contiene el import.
+ * @param imp      - Módulo o paquete importado (ej. `"utils"`, `".helpers"`, `"core.service"`).
+ * @returns        Ruta resuelta o `null` si no se encuentra.
+ */
+function resolvePyImport(importer, imp) {
+    if (imp.startsWith(".")) {
+        const dots = imp.match(/^\.+/)[0].length;
+        let base = dirname(importer);
+        for (let i = 1; i < dots; i++)
+            base = dirname(base);
+        const trimmed = imp.replace(/^\.+/, "");
+        const target = trimmed
+            ? `${base}/${trimmed.replace(/\./g, "/")}`
+            : base;
+        for (const v of [`${target}.py`, `${target}/__init__.py`]) {
+            const normalized = normalizePathValue(v);
+            if (fileExistsInRepoOrFs(normalized))
+                return normalized;
+        }
+        return null;
+    }
+    const base = imp.replace(/\./g, "/");
+    for (const v of [`${base}.py`, `${base}/__init__.py`]) {
+        const normalized = normalizePathValue(v);
+        if (fileExistsInRepoOrFs(normalized))
+            return normalized;
+    }
+    return null;
+}
+/**
+ * Resuelve un import Java buscando en el conjunto pre-cargado de archivos .java.
+ * Evita lanzar un proceso `find` por cada sentencia import (O(n) por archivo → O(1) por import).
+ *
+ * @param imp       - Nombre de clase o paquete Java a resolver.
+ * @param javaFiles - Conjunto de rutas .java del repositorio (construido una vez por análisis).
+ */
+function resolveJavaImport(imp, javaFiles) {
+    if (!/^[a-zA-Z0-9_.]+$/.test(imp))
+        return null;
+    const rel = imp.replace(/\./g, "/") + ".java";
+    for (const f of javaFiles) {
+        if (f === rel || f.endsWith(`/${rel}`))
+            return f;
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Deduplicación de aristas
+// ---------------------------------------------------------------------------
+/**
+ * Elimina aristas duplicadas del grafo de dependencias.
+ *
+ * Una arista duplicada puede ocurrir cuando el mismo par `from → to` aparece
+ * en múltiples sentencias de import dentro del mismo archivo (poco frecuente,
+ * pero posible con barrel imports o re-exports).
+ *
+ * Usa un `Set<string>` de claves `"from=>to"` para detección O(n).
+ */
+function dedupeEdges(edges) {
+    const seen = new Set();
+    const out = [];
+    for (const e of edges) {
+        const key = `${e.from}=>${e.to}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(e);
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Public
+// ---------------------------------------------------------------------------
+/**
+ * Detecta aristas de dependencia entre los archivos cambiados analizando sus
+ * sentencias de importación (TypeScript/JS, Python, Java).
+ *
+ * Solo se incluyen dependencias cuyo destino también esté en el conjunto de
+ * archivos cambiados; las importaciones hacia código no modificado se ignoran.
+ *
+ * Los contenidos de archivos se cachean en memoria para evitar múltiples
+ * llamadas a `readFileSync` o `git show` por el mismo archivo.
+ *
+ * @param files - Rutas relativas de los archivos cambiados en el working tree.
+ * @returns     Array de aristas `{ from, to }` sin duplicados.
+ */
+export function buildDependencyEdges(files) {
+    // Limpiar caché de contenido al iniciar cada análisis para evitar datos obsoletos.
+    // No se limpia _trackedFilesCache: ya es fresca desde getFileStats (llamado antes
+    // en el flujo CLI) y relanzar git ls-files sería redundante.
+    clearDependencyCache();
+    // Construir el conjunto de archivos .java del repositorio una sola vez.
+    // Evita lanzar un subproceso `find` por cada sentencia import Java.
+    const javaFiles = new Set(shSafe("git ls-files -- '*.java'")
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean));
+    const changedSet = new Set(files);
+    const edges = [];
+    for (const file of files) {
+        const lang = detectLanguage(file);
+        const content = readFileForParsing(file);
+        if (lang === "js") {
+            const matches = [
+                ...content.matchAll(/from\s+['"]([^'"]+)['"]/g),
+                ...content.matchAll(/require\(['"]([^'"]+)['"]\)/g),
+                ...content.matchAll(/import\(['"]([^'"]+)['"]\)/g)
+            ];
+            for (const m of matches) {
+                const resolved = resolveJsImport(file, m[1]);
+                if (resolved && changedSet.has(resolved)) {
+                    edges.push({ from: file, to: resolved });
+                }
+            }
+        }
+        if (lang === "py") {
+            const lines = content.split("\n");
+            for (const line of lines) {
+                let m = line.match(/^import\s+([a-zA-Z0-9_.]+)/);
+                if (m) {
+                    const resolved = resolvePyImport(file, m[1]);
+                    if (resolved && changedSet.has(resolved)) {
+                        edges.push({ from: file, to: resolved });
+                    }
+                }
+                m = line.match(/^from\s+([.a-zA-Z0-9_]+)\s+import/);
+                if (m) {
+                    const resolved = resolvePyImport(file, m[1]);
+                    if (resolved && changedSet.has(resolved)) {
+                        edges.push({ from: file, to: resolved });
+                    }
+                }
+            }
+        }
+        if (lang === "java") {
+            const lines = content.split("\n");
+            for (const line of lines) {
+                const m = line.match(/^import\s+([a-zA-Z0-9_.]+);/);
+                if (m) {
+                    const resolved = resolveJavaImport(m[1], javaFiles);
+                    if (resolved && changedSet.has(resolved)) {
+                        edges.push({ from: file, to: resolved });
+                    }
+                }
+            }
+        }
+    }
+    return dedupeEdges(edges);
+}