@yasserkhanorg/e2e-agents 1.3.2 → 1.4.0

package/dist/training/scanner.js

@@ -0,0 +1,391 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverSourceDirs = discoverSourceDirs;
+exports.discoverTestDirs = discoverTestDirs;
+exports.scanProject = scanProject;
+const fs_1 = require("fs");
+const path_1 = require("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 = (0, path_1.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] || (0, path_1.basename)(dirPath));
+}
+function walkDirs(root, projectRoot, category, maxDepth, results, depth = 0) {
+    if (depth > maxDepth || !(0, fs_1.existsSync)(root)) {
+        return;
+    }
+    let entries;
+    try {
+        entries = (0, fs_1.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 = (0, fs_1.lstatSync)((0, path_1.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: (0, path_1.resolve)(root),
+            relativePath: (0, path_1.relative)(projectRoot, root).replace(/\\/g, '/'),
+            category,
+            familyHint: extractFamilyHint(root, projectRoot),
+        });
+    }
+    for (const sub of subdirs) {
+        walkDirs((0, path_1.join)(root, sub), projectRoot, category, maxDepth, results, depth + 1);
+    }
+}
+function discoverSourceDirs(projectRoot) {
+    const results = [];
+    const resolved = (0, path_1.resolve)(projectRoot);
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(resolved);
+    }
+    catch {
+        // ENOENT or EACCES — skip inaccessible entries
+        return results;
+    }
+    for (const entry of entries) {
+        if (isSkipped(entry))
+            continue;
+        const fullPath = (0, path_1.join)(resolved, entry);
+        try {
+            const stat = (0, fs_1.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;
+}
+function discoverTestDirs(projectRoot) {
+    const results = [];
+    const resolved = (0, path_1.resolve)(projectRoot);
+    function walk(dir, category, depth) {
+        if (depth > TEST_MAX_DEPTH || !(0, fs_1.existsSync)(dir))
+            return;
+        let entries;
+        try {
+            entries = (0, fs_1.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: (0, path_1.resolve)(dir),
+                relativePath: (0, path_1.relative)(resolved, dir).replace(/\\/g, '/'),
+                category,
+                familyHint: extractFamilyHint(dir, resolved),
+            });
+        }
+        for (const entry of entries) {
+            if (isSkipped(entry))
+                continue;
+            const full = (0, path_1.join)(dir, entry);
+            try {
+                const stat = (0, fs_1.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((0, path_1.join)(resolved, root), 'test', 0);
+    }
+    for (const root of cypressRoots) {
+        walk((0, path_1.join)(resolved, root), 'cypress', 0);
+    }
+    // Also scan server dirs for Go test files
+    for (const root of SERVER_ROOTS) {
+        const serverPath = (0, path_1.join)(resolved, root);
+        if ((0, fs_1.existsSync)(serverPath)) {
+            walk(serverPath, 'test', 0);
+        }
+    }
+    return results;
+}
+function extractTags(specFiles) {
+    const tags = new Set();
+    for (const file of specFiles) {
+        try {
+            const content = (0, fs_1.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 (0, fs_1.readdirSync)(dir)) {
+            const full = (0, path_1.join)(dir, entry);
+            try {
+                const stat = (0, fs_1.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 (0, fs_1.readdirSync)(dir.path)) {
+                if (isSkipped(entry))
+                    continue;
+                const full = (0, path_1.join)(dir.path, entry);
+                try {
+                    const stat = (0, fs_1.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: (0, path_1.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 (0, fs_1.readdirSync)(testDir.path)) {
+                if (isSkipped(entry))
+                    continue;
+                const full = (0, path_1.join)(testDir.path, entry);
+                try {
+                    const stat = (0, fs_1.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: [(0, path_1.relative)(projectRoot, full).replace(/\\/g, '/') + '/'],
+                    });
+                }
+            }
+        }
+        catch {
+            // ENOENT or EACCES — skip inaccessible directories
+        }
+    }
+    return features;
+}
+function scanProject(projectRoot) {
+    const resolved = (0, path_1.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 += (0, fs_1.readdirSync)(dir.path).filter((e) => {
+                try {
+                    const stat = (0, fs_1.lstatSync)((0, path_1.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/training/types.d.ts

@@ -0,0 +1,109 @@
+import type { RouteFamily, RouteFamilyManifest } from '../knowledge/route_families.js';
+/** A source directory discovered by the scanner */
+export interface DiscoveredDir {
+    /** Absolute path to the directory */
+    path: string;
+    /** Relative path from project root */
+    relativePath: string;
+    /** Category: frontend source, backend source, or test */
+    category: 'webapp' | 'server' | 'test' | 'cypress';
+    /** Deepest meaningful directory name (e.g., 'channels' from 'src/channels/') */
+    familyHint: string;
+}
+/** A family proposed by the deterministic scanner */
+export interface ScannedFamily {
+    id: string;
+    routes: string[];
+    webappPaths: string[];
+    serverPaths: string[];
+    specDirs: string[];
+    cypressSpecDirs: string[];
+    tags: string[];
+    features: ScannedFeature[];
+    /** True if routes are guesses (directory-name-based) */
+    routesGuessed: boolean;
+}
+/** A nested feature proposed by the scanner */
+export interface ScannedFeature {
+    id: string;
+    webappPaths: string[];
+    serverPaths: string[];
+    specDirs: string[];
+}
+/** Output of the deterministic scanner */
+export interface ScanResult {
+    families: ScannedFamily[];
+    unmatchedSourceDirs: DiscoveredDir[];
+    unmatchedTestDirs: DiscoveredDir[];
+    stats: {
+        totalSourceFiles: number;
+        totalTestFiles: number;
+        familyCount: number;
+    };
+}
+/** Output of LLM enrichment */
+export interface EnrichmentResult {
+    enrichedFamilies: RouteFamily[];
+    tokensUsed: number;
+    costUSD: number;
+    skippedFamilies: string[];
+}
+/** A single commit's validation result */
+export interface CommitValidation {
+    hash: string;
+    message: string;
+    changedFiles: string[];
+    boundFiles: number;
+    unboundFiles: string[];
+    familiesHit: string[];
+}
+/** Output of validation mode */
+export interface ValidationReport {
+    totalCommits: number;
+    totalFiles: number;
+    boundFiles: number;
+    unboundFiles: number;
+    coveragePercent: number;
+    commits: CommitValidation[];
+    familyHits: Record<string, number>;
+    neverHitFamilies: string[];
+    unboundFileClusters: Array<{
+        pattern: string;
+        count: number;
+        suggestedFamily: string;
+    }>;
+}
+/** Output of smart merge */
+export interface MergeResult {
+    manifest: RouteFamilyManifest;
+    newFamilies: string[];
+    updatedFamilies: string[];
+    staleFamilies: string[];
+    summary: string;
+}
+/** Options for the train command */
+export interface TrainOptions {
+    /** Path to the application root */
+    appPath: string;
+    /** Path to tests root (may differ from appPath) */
+    testsRoot: string;
+    /** Enable LLM enrichment (default: true) */
+    enrich: boolean;
+    /** Run validation against git history */
+    validate: boolean;
+    /** Git ref for validation (e.g., 'HEAD~20') */
+    since: string;
+    /** GitHub PR number for validation */
+    pr?: number;
+    /** Output path for route-families.json */
+    outputPath: string;
+    /** Dry run — print without writing */
+    dryRun: boolean;
+    /** Non-interactive mode */
+    yes: boolean;
+    /** Max LLM spend in USD */
+    budgetUSD: number;
+}
+/** Routes that look like bare "/<id>" are scanner-generated guesses */
+export declare function isGuessedRoute(routes: string[]): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/training/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/training/types.ts"],"names":[],"mappings":"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"}

package/dist/training/types.js

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

package/dist/training/validator.d.ts

@@ -0,0 +1,16 @@
+import type { RouteFamilyManifest } from '../knowledge/route_families.js';
+import type { CommitValidation, ValidationReport } from './types.js';
+export declare function parseGitLog(log: string): Array<{
+    hash: string;
+    message: string;
+    files: string[];
+}>;
+export declare function getCommitFiles(projectRoot: string, since: string): Array<{
+    hash: string;
+    message: string;
+    files: string[];
+}>;
+export declare function validateCommit(manifest: RouteFamilyManifest, files: string[], hash: string, message: string): CommitValidation;
+export declare function buildValidationReport(commits: CommitValidation[], manifest: RouteFamilyManifest): ValidationReport;
+export declare function formatValidationReport(report: ValidationReport): string;
+//# sourceMappingURL=validator.d.ts.map

package/dist/training/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/training/validator.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAExE,OAAO,KAAK,EAAC,gBAAgB,EAAE,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAEnE,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC,CA6BhG;AAED,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC,CAgB1H;AAED,wBAAgB,cAAc,CAC1B,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GAChB,gBAAgB,CA6BlB;AAED,wBAAgB,qBAAqB,CACjC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,QAAQ,EAAE,mBAAmB,GAC9B,gBAAgB,CAkDlB;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAgCvE"}