@yasserkhanorg/e2e-agents 1.3.2 → 1.4.0

package/dist/esm/training/merger.js

@@ -0,0 +1,137 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { isGuessedRoute } from './types.js';
+function unionArrays(existing, incoming) {
+    const set = new Set(existing || []);
+    for (const item of incoming) {
+        set.add(item);
+    }
+    return Array.from(set);
+}
+function mergeFamily(existing, scanned) {
+    const merged = { ...existing };
+    // Structural fields: union arrays
+    merged.webappPaths = unionArrays(existing.webappPaths, scanned.webappPaths);
+    merged.serverPaths = unionArrays(existing.serverPaths, scanned.serverPaths);
+    merged.specDirs = unionArrays(existing.specDirs, scanned.specDirs);
+    merged.cypressSpecDirs = unionArrays(existing.cypressSpecDirs, scanned.cypressSpecDirs);
+    merged.tags = unionArrays(existing.tags, scanned.tags);
+    // Routes: only update if existing looks like a guess
+    if (isGuessedRoute(existing.routes) && !isGuessedRoute(scanned.routes)) {
+        merged.routes = scanned.routes;
+    }
+    // Human-curated fields: never overwrite (priority, userFlows, pageObjects, components)
+    // Merge features
+    if (scanned.features.length > 0) {
+        const existingFeatures = existing.features || [];
+        const existingIds = new Set(existingFeatures.map((f) => f.id));
+        const newFeatures = scanned.features.filter((f) => !existingIds.has(f.id));
+        if (newFeatures.length > 0) {
+            merged.features = [
+                ...existingFeatures,
+                ...newFeatures.map((f) => ({
+                    id: f.id,
+                    webappPaths: f.webappPaths,
+                    serverPaths: f.serverPaths,
+                    specDirs: f.specDirs,
+                })),
+            ];
+        }
+    }
+    return merged;
+}
+function scannedToRouteFamily(scanned) {
+    const family = {
+        id: scanned.id,
+        routes: scanned.routes,
+    };
+    if (scanned.webappPaths.length > 0)
+        family.webappPaths = scanned.webappPaths;
+    if (scanned.serverPaths.length > 0)
+        family.serverPaths = scanned.serverPaths;
+    if (scanned.specDirs.length > 0)
+        family.specDirs = scanned.specDirs;
+    if (scanned.cypressSpecDirs.length > 0)
+        family.cypressSpecDirs = scanned.cypressSpecDirs;
+    if (scanned.tags.length > 0)
+        family.tags = scanned.tags;
+    if (scanned.features.length > 0) {
+        family.features = scanned.features.map((f) => ({
+            id: f.id,
+            webappPaths: f.webappPaths.length > 0 ? f.webappPaths : undefined,
+            serverPaths: f.serverPaths.length > 0 ? f.serverPaths : undefined,
+            specDirs: f.specDirs.length > 0 ? f.specDirs : undefined,
+        }));
+    }
+    return family;
+}
+export function mergeFamilies(existing, scanned) {
+    const existingFamilies = existing?.families || [];
+    const existingMap = new Map(existingFamilies.map((f) => [f.id, f]));
+    const scannedMap = new Map(scanned.map((f) => [f.id, f]));
+    const newFamilies = [];
+    const updatedFamilies = [];
+    const mergedFamilies = [];
+    // Process existing families
+    for (const ef of existingFamilies) {
+        const sf = scannedMap.get(ef.id);
+        if (sf) {
+            mergedFamilies.push(mergeFamily(ef, sf));
+            updatedFamilies.push(ef.id);
+        }
+        else {
+            // Keep untouched
+            mergedFamilies.push({ ...ef });
+        }
+    }
+    // Add new families from scanner
+    for (const sf of scanned) {
+        if (!existingMap.has(sf.id)) {
+            mergedFamilies.push(scannedToRouteFamily(sf));
+            newFamilies.push(sf.id);
+        }
+    }
+    const parts = [];
+    if (updatedFamilies.length > 0)
+        parts.push(`${updatedFamilies.length} families updated`);
+    if (newFamilies.length > 0)
+        parts.push(`${newFamilies.length} new families added`);
+    if (parts.length === 0)
+        parts.push('no changes');
+    return {
+        manifest: { families: mergedFamilies, source: existing?.source || 'train-scan' },
+        newFamilies,
+        updatedFamilies,
+        staleFamilies: [],
+        summary: parts.join(', '),
+    };
+}
+export function detectStaleFamilies(manifest, projectRoot) {
+    const resolved = resolve(projectRoot);
+    const stale = [];
+    for (const family of manifest.families) {
+        const allPatterns = [
+            ...(family.webappPaths || []),
+            ...(family.serverPaths || []),
+            ...(family.specDirs || []),
+        ];
+        if (allPatterns.length === 0)
+            continue;
+        // Check if any pattern resolves to existing files/dirs
+        let hasAny = false;
+        for (const pattern of allPatterns) {
+            // Strip trailing glob (* or **) to get the directory
+            const dirPart = pattern.replace(/\/?\*.*$/, '');
+            if (dirPart && existsSync(join(resolved, dirPart))) {
+                hasAny = true;
+                break;
+            }
+        }
+        if (!hasAny) {
+            stale.push(family.id);
+        }
+    }
+    return stale;
+}

package/dist/esm/training/scanner.js

@@ -0,0 +1,386 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { readdirSync, readFileSync, lstatSync, existsSync } from 'fs';
+import { join, relative, basename, resolve } from 'path';
+const SOURCE_MAX_DEPTH = 3;
+// One deeper than source to account for test framework wrapper dirs (e2e/, integration/)
+const TEST_MAX_DEPTH = 5;
+const SPEC_FILES_MAX_DEPTH = 10;
+const SOURCE_ROOTS = ['src', 'app', 'pages', 'components', 'features', 'modules'];
+const SERVER_ROOTS = ['server', 'api', 'cmd', 'model', 'services'];
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', '.next', '.nuxt', 'dist', 'build',
+    'coverage', '__pycache__', '.e2e-ai-agents', '.cache',
+    'vendor', 'third_party',
+]);
+const TEST_EXTENSIONS = ['.spec.ts', '.test.ts', '.spec.js', '.test.js', '.spec.tsx', '.test.tsx'];
+const GO_TEST_SUFFIX = '_test.go';
+/** Type-safe includes check for readonly arrays */
+const includes = (arr, v) => arr.includes(v);
+function isSkipped(name) {
+    return name.startsWith('.') || SKIP_DIRS.has(name);
+}
+function normalizeId(name) {
+    return name
+        .replace(/[A-Z]/g, (c, idx) => (idx > 0 ? `_${c.toLowerCase()}` : c.toLowerCase()))
+        .replace(/[^a-z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+}
+function extractFamilyHint(dirPath, projectRoot) {
+    const rel = relative(projectRoot, dirPath).replace(/\\/g, '/');
+    const parts = rel.split('/').filter(Boolean);
+    // Skip the root category dir (src/, server/, tests/, etc.)
+    // Return the first meaningful subdirectory name
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (!isSkipped(part) && part !== 'e2e' && part !== 'integration' && part !== 'functional') {
+            return normalizeId(part);
+        }
+    }
+    return normalizeId(parts[parts.length - 1] || basename(dirPath));
+}
+function walkDirs(root, projectRoot, category, maxDepth, results, depth = 0) {
+    if (depth > maxDepth || !existsSync(root)) {
+        return;
+    }
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        // ENOENT or EACCES — skip inaccessible entries
+        return;
+    }
+    const hasSourceFiles = entries.some((e) => {
+        const ext = e.slice(e.lastIndexOf('.'));
+        return ['.ts', '.tsx', '.js', '.jsx', '.go', '.py', '.rs'].includes(ext);
+    });
+    const subdirs = entries.filter((e) => {
+        if (isSkipped(e))
+            return false;
+        try {
+            const stat = lstatSync(join(root, e));
+            if (stat.isSymbolicLink())
+                return false;
+            return stat.isDirectory();
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible entries
+            return false;
+        }
+    });
+    if (hasSourceFiles && depth >= 1) {
+        results.push({
+            path: resolve(root),
+            relativePath: relative(projectRoot, root).replace(/\\/g, '/'),
+            category,
+            familyHint: extractFamilyHint(root, projectRoot),
+        });
+    }
+    for (const sub of subdirs) {
+        walkDirs(join(root, sub), projectRoot, category, maxDepth, results, depth + 1);
+    }
+}
+export function discoverSourceDirs(projectRoot) {
+    const results = [];
+    const resolved = resolve(projectRoot);
+    let entries;
+    try {
+        entries = readdirSync(resolved);
+    }
+    catch {
+        // ENOENT or EACCES — skip inaccessible entries
+        return results;
+    }
+    for (const entry of entries) {
+        if (isSkipped(entry))
+            continue;
+        const fullPath = join(resolved, entry);
+        try {
+            const stat = lstatSync(fullPath);
+            if (stat.isSymbolicLink() || !stat.isDirectory())
+                continue;
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible entries
+            continue;
+        }
+        if (includes(SOURCE_ROOTS, entry)) {
+            walkDirs(fullPath, resolved, 'webapp', SOURCE_MAX_DEPTH, results);
+        }
+        else if (includes(SERVER_ROOTS, entry)) {
+            walkDirs(fullPath, resolved, 'server', SOURCE_MAX_DEPTH, results);
+        }
+    }
+    return results;
+}
+export function discoverTestDirs(projectRoot) {
+    const results = [];
+    const resolved = resolve(projectRoot);
+    function walk(dir, category, depth) {
+        if (depth > TEST_MAX_DEPTH || !existsSync(dir))
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible entries
+            return;
+        }
+        const hasTests = entries.some((e) => {
+            return TEST_EXTENSIONS.some((ext) => e.endsWith(ext)) || e.endsWith(GO_TEST_SUFFIX);
+        });
+        if (hasTests) {
+            results.push({
+                path: resolve(dir),
+                relativePath: relative(resolved, dir).replace(/\\/g, '/'),
+                category,
+                familyHint: extractFamilyHint(dir, resolved),
+            });
+        }
+        for (const entry of entries) {
+            if (isSkipped(entry))
+                continue;
+            const full = join(dir, entry);
+            try {
+                const stat = lstatSync(full);
+                if (stat.isSymbolicLink())
+                    continue;
+                if (stat.isDirectory()) {
+                    walk(full, category, depth + 1);
+                }
+            }
+            catch {
+                // ENOENT or EACCES — skip inaccessible entries
+            }
+        }
+    }
+    const testRoots = ['tests', 'test', 'e2e-tests', 'e2e', 'specs', 'spec'];
+    const cypressRoots = ['cypress/e2e', 'cypress/integration'];
+    for (const root of testRoots) {
+        walk(join(resolved, root), 'test', 0);
+    }
+    for (const root of cypressRoots) {
+        walk(join(resolved, root), 'cypress', 0);
+    }
+    // Also scan server dirs for Go test files
+    for (const root of SERVER_ROOTS) {
+        const serverPath = join(resolved, root);
+        if (existsSync(serverPath)) {
+            walk(serverPath, 'test', 0);
+        }
+    }
+    return results;
+}
+function extractTags(specFiles) {
+    const tags = new Set();
+    for (const file of specFiles) {
+        try {
+            const content = readFileSync(file, 'utf-8');
+            const matches = content.match(/@[a-zA-Z][a-zA-Z0-9_-]*/g);
+            if (matches) {
+                for (const m of matches) {
+                    if (!m.startsWith('@playwright') && !m.startsWith('@param') && !m.startsWith('@returns')) {
+                        tags.add(m);
+                    }
+                }
+            }
+        }
+        catch {
+            // ENOENT or EACCES — skip unreadable files
+        }
+    }
+    return Array.from(tags);
+}
+function getSpecFiles(dir, depth = 0) {
+    if (depth > SPEC_FILES_MAX_DEPTH)
+        return [];
+    const files = [];
+    try {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            try {
+                const stat = lstatSync(full);
+                if (stat.isSymbolicLink())
+                    continue;
+                if (stat.isDirectory()) {
+                    files.push(...getSpecFiles(full, depth + 1));
+                }
+                else if (TEST_EXTENSIONS.some((ext) => entry.endsWith(ext))) {
+                    files.push(full);
+                }
+            }
+            catch {
+                // ENOENT or EACCES — skip inaccessible entries
+            }
+        }
+    }
+    catch {
+        // ENOENT or EACCES — skip inaccessible directories
+    }
+    return files;
+}
+function buildGlobPattern(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    return `${normalized}/*`;
+}
+function groupByFamily(dirs) {
+    const groups = new Map();
+    for (const dir of dirs) {
+        const key = normalizeId(dir.familyHint);
+        if (!groups.has(key)) {
+            groups.set(key, { webapp: [], server: [], test: [], cypress: [] });
+        }
+        const group = groups.get(key);
+        if (dir.category === 'webapp')
+            group.webapp.push(dir);
+        else if (dir.category === 'server')
+            group.server.push(dir);
+        else if (dir.category === 'cypress')
+            group.cypress.push(dir);
+        else
+            group.test.push(dir);
+    }
+    return groups;
+}
+function detectFeatures(familyId, group, projectRoot) {
+    const features = [];
+    const webappSubdirs = new Map();
+    for (const dir of group.webapp) {
+        try {
+            for (const entry of readdirSync(dir.path)) {
+                if (isSkipped(entry))
+                    continue;
+                const full = join(dir.path, entry);
+                try {
+                    const stat = lstatSync(full);
+                    if (stat.isSymbolicLink())
+                        continue;
+                    if (stat.isDirectory()) {
+                        const hint = normalizeId(entry);
+                        if (!webappSubdirs.has(hint))
+                            webappSubdirs.set(hint, []);
+                        webappSubdirs.get(hint).push({
+                            path: full,
+                            relativePath: relative(projectRoot, full).replace(/\\/g, '/'),
+                            category: 'webapp',
+                            familyHint: entry,
+                        });
+                    }
+                }
+                catch {
+                    // ENOENT or EACCES — skip inaccessible entries
+                }
+            }
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible directories
+        }
+    }
+    for (const testDir of group.test) {
+        try {
+            for (const entry of readdirSync(testDir.path)) {
+                if (isSkipped(entry))
+                    continue;
+                const full = join(testDir.path, entry);
+                try {
+                    const stat = lstatSync(full);
+                    if (stat.isSymbolicLink())
+                        continue;
+                    if (!stat.isDirectory())
+                        continue;
+                }
+                catch {
+                    // ENOENT or EACCES — skip inaccessible entries
+                    continue;
+                }
+                const hint = normalizeId(entry);
+                if (webappSubdirs.has(hint)) {
+                    const webDirs = webappSubdirs.get(hint);
+                    features.push({
+                        id: `${familyId}/${hint}`,
+                        webappPaths: webDirs.map((d) => buildGlobPattern(d.relativePath)),
+                        serverPaths: [],
+                        specDirs: [relative(projectRoot, full).replace(/\\/g, '/') + '/'],
+                    });
+                }
+            }
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible directories
+        }
+    }
+    return features;
+}
+export function scanProject(projectRoot) {
+    const resolved = resolve(projectRoot);
+    const sourceDirs = discoverSourceDirs(resolved);
+    const testDirs = discoverTestDirs(resolved);
+    const allDirs = [...sourceDirs, ...testDirs];
+    const groups = groupByFamily(allDirs);
+    const families = [];
+    for (const [familyId, group] of groups) {
+        const hasSrc = group.webapp.length > 0 || group.server.length > 0;
+        const hasTests = group.test.length > 0 || group.cypress.length > 0;
+        if (!hasSrc && !hasTests)
+            continue;
+        const allSpecFiles = [];
+        for (const td of [...group.test, ...group.cypress]) {
+            allSpecFiles.push(...getSpecFiles(td.path));
+        }
+        const features = detectFeatures(familyId, group, resolved);
+        families.push({
+            id: familyId,
+            routes: [`/${familyId}`],
+            webappPaths: group.webapp.map((d) => buildGlobPattern(d.relativePath)),
+            serverPaths: group.server.map((d) => buildGlobPattern(d.relativePath)),
+            specDirs: group.test.map((d) => d.relativePath + '/'),
+            cypressSpecDirs: group.cypress.map((d) => d.relativePath + '/'),
+            tags: extractTags(allSpecFiles),
+            features,
+            routesGuessed: true,
+        });
+    }
+    const familyIds = new Set(families.map((f) => f.id));
+    const unmatchedSourceDirs = sourceDirs.filter((d) => !familyIds.has(normalizeId(d.familyHint)));
+    const unmatchedTestDirs = testDirs.filter((d) => !familyIds.has(normalizeId(d.familyHint)));
+    let totalSourceFiles = 0;
+    let totalTestFiles = 0;
+    for (const dir of sourceDirs) {
+        try {
+            totalSourceFiles += readdirSync(dir.path).filter((e) => {
+                try {
+                    const stat = lstatSync(join(dir.path, e));
+                    return !stat.isSymbolicLink() && !stat.isDirectory();
+                }
+                catch {
+                    // ENOENT or EACCES — skip inaccessible entries
+                    return false;
+                }
+            }).length;
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible directories
+        }
+    }
+    for (const dir of testDirs) {
+        try {
+            totalTestFiles += getSpecFiles(dir.path).length;
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible directories
+        }
+    }
+    return {
+        families,
+        unmatchedSourceDirs,
+        unmatchedTestDirs,
+        stats: {
+            totalSourceFiles,
+            totalTestFiles,
+            familyCount: families.length,
+        },
+    };
+}

package/dist/esm/training/types.js

@@ -0,0 +1,6 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/** Routes that look like bare "/<id>" are scanner-generated guesses */
+export function isGuessedRoute(routes) {
+    return routes.every((r) => /^\/[a-z][a-z0-9_]*$/.test(r));
+}

package/dist/esm/training/validator.js

@@ -0,0 +1,153 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { execFileSync } from 'child_process';
+import { resolve } from 'path';
+import { bindFilesToFamilies } from '../knowledge/route_families.js';
+export function parseGitLog(log) {
+    const commits = [];
+    let current = null;
+    for (const line of log.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            if (current) {
+                commits.push(current);
+                current = null;
+            }
+            continue;
+        }
+        if (trimmed.includes('|') && /^[0-9a-f]{7,40}\|/.test(trimmed)) {
+            if (current) {
+                commits.push(current);
+            }
+            const [hash, ...rest] = trimmed.split('|');
+            current = { hash, message: rest.join('|'), files: [] };
+        }
+        else if (current) {
+            current.files.push(trimmed);
+        }
+    }
+    if (current) {
+        commits.push(current);
+    }
+    return commits;
+}
+export function getCommitFiles(projectRoot, since) {
+    const resolved = resolve(projectRoot);
+    let log;
+    try {
+        log = execFileSync('git', ['log', '--name-only', '--pretty=format:%H|%s', `${since}..HEAD`], {
+            cwd: resolved,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    catch (error) {
+        console.warn(`[train] git log failed: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+    return parseGitLog(log);
+}
+export function validateCommit(manifest, files, hash, message) {
+    // Filter out non-source files
+    const sourceFiles = files.filter((f) => {
+        return !f.endsWith('.md') && !f.endsWith('.json') && !f.endsWith('.yml') && !f.endsWith('.yaml') &&
+            !f.startsWith('.') && !f.includes('node_modules/');
+    });
+    if (sourceFiles.length === 0) {
+        return { hash, message, changedFiles: [], boundFiles: 0, unboundFiles: [], familiesHit: [] };
+    }
+    const bindings = bindFilesToFamilies(sourceFiles, manifest);
+    const bound = bindings.filter((b) => b.bindings.length > 0);
+    const unbound = bindings.filter((b) => b.bindings.length === 0);
+    const familiesHit = new Set();
+    for (const b of bound) {
+        for (const binding of b.bindings) {
+            familiesHit.add(binding.family);
+        }
+    }
+    return {
+        hash,
+        message,
+        changedFiles: sourceFiles,
+        boundFiles: bound.length,
+        unboundFiles: unbound.map((b) => b.file),
+        familiesHit: Array.from(familiesHit),
+    };
+}
+export function buildValidationReport(commits, manifest) {
+    let totalFiles = 0;
+    let boundFiles = 0;
+    let unboundFiles = 0;
+    const familyHits = {};
+    const unboundCounts = {};
+    for (const commit of commits) {
+        totalFiles += commit.changedFiles.length;
+        boundFiles += commit.boundFiles;
+        unboundFiles += commit.unboundFiles.length;
+        for (const fam of commit.familiesHit) {
+            familyHits[fam] = (familyHits[fam] || 0) + 1;
+        }
+        for (const uf of commit.unboundFiles) {
+            unboundCounts[uf] = (unboundCounts[uf] || 0) + 1;
+        }
+    }
+    const allFamilyIds = manifest.families.map((f) => f.id);
+    const hitFamilyIds = new Set(Object.keys(familyHits));
+    const neverHitFamilies = allFamilyIds.filter((id) => !hitFamilyIds.has(id));
+    // Cluster unbound files by directory
+    const dirCounts = {};
+    for (const [file, count] of Object.entries(unboundCounts)) {
+        const dir = file.split('/').slice(0, -1).join('/');
+        dirCounts[dir] = (dirCounts[dir] || 0) + count;
+    }
+    const unboundFileClusters = Object.entries(dirCounts)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 20)
+        .map(([pattern, count]) => ({
+        pattern: `${pattern}/*`,
+        count,
+        suggestedFamily: pattern.split('/').pop() || 'unknown',
+    }));
+    return {
+        totalCommits: commits.length,
+        totalFiles,
+        boundFiles,
+        unboundFiles,
+        coveragePercent: totalFiles > 0 ? Math.round((boundFiles / totalFiles) * 100) : 100,
+        commits,
+        familyHits,
+        neverHitFamilies,
+        unboundFileClusters,
+    };
+}
+export function formatValidationReport(report) {
+    const lines = [];
+    lines.push(`Validated against ${report.totalCommits} commits`);
+    lines.push('');
+    lines.push(`Coverage: ${report.coveragePercent}% of files bound (${report.boundFiles}/${report.totalFiles})`);
+    lines.push('');
+    // Family hit distribution
+    const sorted = Object.entries(report.familyHits).sort(([, a], [, b]) => b - a);
+    if (sorted.length > 0) {
+        lines.push('Family hit distribution:');
+        const maxHits = sorted[0][1];
+        for (const [family, hits] of sorted) {
+            const bar = '\u2588'.repeat(Math.max(1, Math.round((hits / maxHits) * 12)));
+            lines.push(`  ${family.padEnd(20)} ${bar} ${hits} commits`);
+        }
+        if (report.neverHitFamilies.length > 0) {
+            lines.push(`  (never hit)${' '.repeat(8)}${report.neverHitFamilies.join(', ')}`);
+        }
+        lines.push('');
+    }
+    // Unbound file clusters
+    if (report.unboundFileClusters.length > 0) {
+        lines.push(`Unbound files (${report.unboundFiles} files across ${report.totalCommits} commits):`);
+        for (const cluster of report.unboundFileClusters.slice(0, 10)) {
+            lines.push(`  ${cluster.pattern.padEnd(50)} — ${cluster.count} commits (suggest: ${cluster.suggestedFamily})`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/index.d.ts

@@ -54,4 +54,9 @@ export type { PlanReport } from './agent/plan.js';
 export { runAgenticGeneration } from './agentic/runner.js';
 export type { ScenarioInput, AgenticRunOptions } from './agentic/runner.js';
 export type { AgenticConfig, AgenticResult, AgenticSummary, PlaywrightRunResult, TestFailure } from './agentic/types.js';
+export { scanProject } from './training/scanner.js';
+export { mergeFamilies, detectStaleFamilies } from './training/merger.js';
+export { enrichFamilies } from './training/enricher.js';
+export { getCommitFiles, validateCommit, buildValidationReport, formatValidationReport } from './training/validator.js';
+export type { ScanResult, ScannedFamily, ScannedFeature, DiscoveredDir, EnrichmentResult, ValidationReport, CommitValidation, MergeResult, TrainOptions, } from './training/types.js';
 //# sourceMappingURL=index.d.ts.map