@yasserkhanorg/e2e-agents 1.5.0 → 1.7.0

package/dist/esm/training/scanner.js

@@ -15,6 +15,50 @@ const SKIP_DIRS = new Set([
 ]);
 const TEST_EXTENSIONS = ['.spec.ts', '.test.ts', '.spec.js', '.test.js', '.spec.tsx', '.test.tsx'];
 const GO_TEST_SUFFIX = '_test.go';
+/**
+ * Test category directories that organize tests but aren't feature families.
+ * Test-only families matching these names are excluded.
+ */
+const TEST_CATEGORY_DIRS = new Set([
+    'specs', 'spec', 'accessibility', 'visual', 'smoke', 'regression',
+    'integration', 'functional', 'unit', 'e2e', 'performance', 'load',
+]);
+/**
+ * Structural directories that are code-organization concerns, not feature families.
+ * Discovered source dirs matching these names are excluded from family creation.
+ */
+const STRUCTURAL_DIRS = new Set([
+    'actions', 'client', 'components', 'hooks', 'i18n', 'packages',
+    'reducers', 'selectors', 'store', 'stores', 'tests', 'types',
+    'utils', 'helpers', 'lib', 'common', 'shared', 'constants',
+    'config', 'styles', 'sass', 'css', 'assets', 'images', 'fonts',
+    'middleware', 'contexts', 'providers', 'layouts', 'templates',
+]);
+/**
+ * Server Go files that are infrastructure / cross-cutting concerns,
+ * not feature-specific domains.  Matched after stripping _local/_store suffixes.
+ */
+const SERVER_INFRA_FILES = new Set([
+    'api', 'apitestlib', 'context', 'helpers', 'params', 'swagger',
+    'app', 'server', 'enterprise', 'product_service', 'security_update_check',
+    'store', 'adapters', 'errors', 'integrity', 'migrate', 'doc',
+    'main', 'init', 'cluster_discovery', 'web_conn', 'web_broadcast_hooks',
+    'manualtesting', 'testlib', 'router', 'handler', 'opentracing',
+    'platform', 'focalboard', 'playbooks', 'client4', 'model',
+    'manifest', 'permission', 'log', 'utils',
+]);
+/**
+ * Server tier directories to scan for Go domain files.
+ * Each tier represents a layer of the backend architecture.
+ */
+const SERVER_TIERS = [
+    'channels/api4',
+    'channels/app',
+    'channels/store/sqlstore',
+    'channels/web',
+    'channels/wsapi',
+    'public/model',
+];
 /** Type-safe includes check for readonly arrays */
 const includes = (arr, v) => arr.includes(v);
 function isSkipped(name) {
@@ -314,10 +358,385 @@ function detectFeatures(familyId, group, projectRoot) {
     }
     return features;
 }
-export function scanProject(projectRoot) {
+/**
+ * Discover families by walking the test directory tree at depth ≥ 2.
+ *
+ * This is the primary family discovery mechanism for projects where source
+ * code is organized by code type (components/, actions/) but tests are
+ * organized by feature (channels/drafts/, channels/search/).
+ *
+ * Each leaf test directory (containing spec files) at meaningful depth ≥ 2
+ * becomes a candidate family.  Top-level feature dirs (depth 1) are already
+ * discovered by the standard `discoverTestDirs` + `groupByFamily` pipeline.
+ */
+/**
+ * Normalize a Go filename into a family domain identifier.
+ * Strips _local, _store, trailing 's' (plurals), and normalizes casing.
+ */
+function normalizeServerDomain(baseName) {
+    let name = baseName;
+    // Strip common suffixes
+    name = name.replace(/_local$/, '');
+    name = name.replace(/_store$/, '');
+    // Skip very short names (e.g., single-letter files)
+    if (name.length < 3)
+        return null;
+    return normalizeId(name);
+}
+/**
+ * Given a domain name like "channel_bookmark", find its parent domain
+ * if a shorter prefix exists in the set (e.g., "channel").
+ * This groups related server files under a single family.
+ */
+function findParentDomain(name, allDomains) {
+    const parts = name.split('_');
+    // Try progressively shorter prefixes
+    for (let i = parts.length - 1; i >= 1; i--) {
+        const candidate = parts.slice(0, i).join('_');
+        if (allDomains.has(candidate) && candidate !== name) {
+            return candidate;
+        }
+    }
+    return name;
+}
+/**
+ * Discover families by scanning server Go source files.
+ *
+ * The backend follows a three-tier pattern:
+ *   api4/draft.go + app/draft.go + store/sqlstore/draft_store.go
+ *
+ * Related files are grouped under parent domains:
+ *   channel.go, channel_bookmark.go, channel_category.go → "channel" family
+ *
+ * Each domain becomes a candidate family with precise serverPaths.
+ */
+export function discoverServerDerivedFamilies(serverRoot) {
+    const resolved = resolve(serverRoot);
+    // First pass: collect all raw domain names across tiers
+    const allRawDomains = new Set();
+    // domain → tier → Set<file basenames>
+    const domainTierFiles = new Map();
+    function collectGoFile(entry, tierRelPath) {
+        if (!entry.endsWith('.go') || entry.endsWith('_test.go') || entry.startsWith('.'))
+            return;
+        const baseName = entry.replace('.go', '');
+        const domain = normalizeServerDomain(baseName);
+        if (!domain || SERVER_INFRA_FILES.has(domain))
+            return;
+        allRawDomains.add(domain);
+        if (!domainTierFiles.has(domain))
+            domainTierFiles.set(domain, new Map());
+        const tierMap = domainTierFiles.get(domain);
+        if (!tierMap.has(tierRelPath))
+            tierMap.set(tierRelPath, new Set());
+        tierMap.get(tierRelPath).add(baseName);
+    }
+    for (const tier of SERVER_TIERS) {
+        const tierPath = join(resolved, tier);
+        if (!existsSync(tierPath))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(tierPath);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            collectGoFile(entry, tier);
+            // Also check subdirectories (e.g., app/slashcommands/, app/users/)
+            const subPath = join(tierPath, entry);
+            try {
+                const stat = lstatSync(subPath);
+                if (stat.isDirectory() && !isSkipped(entry)) {
+                    const subEntries = readdirSync(subPath);
+                    for (const subEntry of subEntries) {
+                        collectGoFile(subEntry, `${tier}/${entry}`);
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    // Scan job directories — each subdirectory is a job type
+    const jobsPath = join(resolved, 'channels/jobs');
+    if (existsSync(jobsPath)) {
+        try {
+            for (const entry of readdirSync(jobsPath)) {
+                const jobPath = join(jobsPath, entry);
+                try {
+                    if (!lstatSync(jobPath).isDirectory() || isSkipped(entry))
+                        continue;
+                    const domain = normalizeId(entry);
+                    if (SERVER_INFRA_FILES.has(domain))
+                        continue;
+                    allRawDomains.add(domain);
+                    const jobFiles = readdirSync(jobPath);
+                    for (const jf of jobFiles) {
+                        if (jf.endsWith('.go') && !jf.endsWith('_test.go')) {
+                            if (!domainTierFiles.has(domain))
+                                domainTierFiles.set(domain, new Map());
+                            const tierMap = domainTierFiles.get(domain);
+                            const tierKey = `channels/jobs/${entry}`;
+                            if (!tierMap.has(tierKey))
+                                tierMap.set(tierKey, new Set());
+                            tierMap.get(tierKey).add(jf.replace('.go', ''));
+                        }
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Second pass: group child domains under parents
+    // e.g., channel_bookmark → channel, post_priority → post
+    // Track which top-level tiers each family touches for significance filtering.
+    const familyPaths = new Map();
+    const familyTiers = new Map();
+    for (const [domain, tierMap] of domainTierFiles) {
+        const parentDomain = findParentDomain(domain, allRawDomains);
+        if (!familyPaths.has(parentDomain))
+            familyPaths.set(parentDomain, new Set());
+        if (!familyTiers.has(parentDomain))
+            familyTiers.set(parentDomain, new Set());
+        const paths = familyPaths.get(parentDomain);
+        const tiers = familyTiers.get(parentDomain);
+        for (const [tierRelPath, fileNames] of tierMap) {
+            // Track the top-level tier (e.g., "channels/api4" from "channels/api4/slashcommands")
+            const topTier = tierRelPath.split('/').slice(0, 2).join('/');
+            tiers.add(topTier);
+            for (const baseName of fileNames) {
+                // Use directory-level glob to capture the file and related variants
+                paths.add(`server/${tierRelPath}/${baseName}*.go`);
+            }
+        }
+    }
+    // Build families from grouped domains.
+    // Multi-tier families (≥2 tiers) can be new families.
+    // Single-tier families can only merge into existing families.
+    const multiTierFamilies = [];
+    const singleTierFamilies = [];
+    for (const [domain, paths] of familyPaths) {
+        if (paths.size === 0)
+            continue;
+        const tierCount = familyTiers.get(domain)?.size ?? 0;
+        const family = {
+            id: domain,
+            routes: [`/${domain.replace(/_/g, '-')}`],
+            webappPaths: [],
+            serverPaths: Array.from(paths),
+            specDirs: [],
+            cypressSpecDirs: [],
+            tags: [],
+            features: [],
+            routesGuessed: true,
+        };
+        if (tierCount >= 2) {
+            multiTierFamilies.push(family);
+        }
+        else {
+            singleTierFamilies.push(family);
+        }
+    }
+    return { multiTierFamilies, singleTierFamilies };
+}
+export function discoverTestDerivedFamilies(testsRoot) {
+    const resolved = resolve(testsRoot);
+    const candidates = [];
+    function walk(dir, depth) {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        const hasSpecs = entries.some((e) => TEST_EXTENSIONS.some((ext) => e.endsWith(ext)) || e.endsWith(GO_TEST_SUFFIX));
+        const subdirs = entries.filter((e) => {
+            if (isSkipped(e))
+                return false;
+            try {
+                const stat = lstatSync(join(dir, e));
+                return !stat.isSymbolicLink() && stat.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        const relPath = relative(resolved, dir).replace(/\\/g, '/');
+        const parts = relPath.split('/').filter(Boolean);
+        const meaningful = parts.filter((p) => !TEST_CATEGORY_DIRS.has(normalizeId(p)) && !isSkipped(p));
+        // Depth-2+ meaningful dirs with spec files → candidate families
+        if (meaningful.length >= 2 && hasSpecs) {
+            const leafId = normalizeId(meaningful[meaningful.length - 1]);
+            const parentId = normalizeId(meaningful[meaningful.length - 2]);
+            if (!STRUCTURAL_DIRS.has(leafId) && !TEST_CATEGORY_DIRS.has(leafId)) {
+                candidates.push({ dir, relPath, leafId, parentId });
+            }
+        }
+        for (const sub of subdirs) {
+            walk(join(dir, sub), depth + 1);
+        }
+    }
+    // Walk from standard test roots
+    const testRoots = ['tests', 'test', 'e2e-tests', 'e2e', 'specs', 'spec'];
+    for (const root of testRoots) {
+        const rootPath = join(resolved, root);
+        if (existsSync(rootPath)) {
+            walk(rootPath, 0);
+        }
+    }
+    // Detect leaf-name collisions across parents
+    const idCount = new Map();
+    for (const c of candidates) {
+        idCount.set(c.leafId, (idCount.get(c.leafId) || 0) + 1);
+    }
+    // Build families — prefix with parent when names collide
+    const familyMap = new Map();
+    for (const c of candidates) {
+        let familyId = c.leafId;
+        if ((idCount.get(c.leafId) || 0) > 1 && c.parentId) {
+            familyId = `${c.parentId}_${c.leafId}`;
+        }
+        if (!familyMap.has(familyId)) {
+            const specFiles = getSpecFiles(c.dir);
+            familyMap.set(familyId, {
+                id: familyId,
+                routes: [`/${familyId.replace(/_/g, '-')}`],
+                webappPaths: [],
+                serverPaths: [],
+                specDirs: [c.relPath + '/'],
+                cypressSpecDirs: [],
+                tags: extractTags(specFiles),
+                features: [],
+                routesGuessed: true,
+            });
+        }
+        else {
+            const existing = familyMap.get(familyId);
+            const specDir = c.relPath + '/';
+            if (!existing.specDirs.includes(specDir)) {
+                existing.specDirs.push(specDir);
+                existing.tags = [...new Set([...existing.tags, ...extractTags(getSpecFiles(c.dir))])];
+            }
+        }
+    }
+    return Array.from(familyMap.values());
+}
+/**
+ * Discover test library paths (page objects, helpers) organized by feature.
+ * Walks well-known test lib directories and maps subdirectories to family IDs.
+ */
+export function discoverTestLibPaths(testsRoot) {
+    const resolved = resolve(testsRoot);
+    const result = new Map();
+    const libDirs = [
+        'lib/src/ui/components',
+        'lib/src/ui/pages',
+        'lib/src/server',
+    ];
+    for (const libDir of libDirs) {
+        const fullDir = join(resolved, libDir);
+        if (!existsSync(fullDir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(fullDir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (isSkipped(entry))
+                continue;
+            const fullPath = join(fullDir, entry);
+            try {
+                const stat = lstatSync(fullPath);
+                if (stat.isSymbolicLink() || !stat.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const familyId = normalizeId(entry);
+            const relPath = relative(resolved, fullPath).replace(/\\/g, '/');
+            const pattern = `${relPath}/*`;
+            if (!result.has(familyId))
+                result.set(familyId, []);
+            result.get(familyId).push(pattern);
+        }
+    }
+    return result;
+}
+/**
+ * Discover files in well-known directories (types, utils) whose basename
+ * maps directly to a family ID.
+ */
+export function discoverNameMatchedPaths(appPath, gitRepoRoot) {
+    const result = new Map();
+    const resolvedApp = resolve(appPath);
+    const scanRoots = [
+        { root: join(resolvedApp, 'src/utils'), base: resolvedApp },
+        { root: join(resolvedApp, 'src/types'), base: resolvedApp },
+    ];
+    // Monorepo-aware: scan platform types directory
+    if (gitRepoRoot) {
+        const resolvedGitRoot = resolve(gitRepoRoot);
+        const platformTypes = join(resolvedGitRoot, 'webapp/platform/types/src');
+        if (existsSync(platformTypes)) {
+            scanRoots.push({ root: platformTypes, base: resolvedGitRoot });
+        }
+        const platformClient = join(resolvedGitRoot, 'webapp/platform/client/src');
+        if (existsSync(platformClient)) {
+            scanRoots.push({ root: platformClient, base: resolvedGitRoot });
+        }
+    }
+    for (const { root, base } of scanRoots) {
+        if (!existsSync(root))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.startsWith('.'))
+                continue;
+            const ext = entry.slice(entry.lastIndexOf('.'));
+            if (!['.ts', '.tsx', '.js', '.jsx'].includes(ext))
+                continue;
+            const fullPath = join(root, entry);
+            try {
+                const stat = lstatSync(fullPath);
+                if (!stat.isFile() || stat.isSymbolicLink())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            // Strip extension and normalize
+            const baseName = entry.slice(0, entry.lastIndexOf('.'));
+            const familyId = normalizeId(baseName);
+            if (familyId.length < 3)
+                continue;
+            const relPath = relative(base, fullPath).replace(/\\/g, '/');
+            if (!result.has(familyId))
+                result.set(familyId, []);
+            result.get(familyId).push(relPath);
+        }
+    }
+    return result;
+}
+export function scanProject(projectRoot, testsRoot, serverRoot, gitRepoRoot) {
     const resolved = resolve(projectRoot);
+    const resolvedTestsRoot = testsRoot ? resolve(testsRoot) : resolved;
     const sourceDirs = discoverSourceDirs(resolved);
-    const testDirs = discoverTestDirs(resolved);
+    const testDirs = discoverTestDirs(resolvedTestsRoot);
     const allDirs = [...sourceDirs, ...testDirs];
     const groups = groupByFamily(allDirs);
     const families = [];
@@ -326,6 +745,13 @@ export function scanProject(projectRoot) {
         const hasTests = group.test.length > 0 || group.cypress.length > 0;
         if (!hasSrc && !hasTests)
             continue;
+        // Skip structural directories that are code-organization, not features.
+        // Only skip if they have source dirs but no corresponding test dirs.
+        if (STRUCTURAL_DIRS.has(familyId) && !hasTests)
+            continue;
+        // Skip test-only families that match broad test categories (not feature families).
+        if (!hasSrc && hasTests && TEST_CATEGORY_DIRS.has(familyId))
+            continue;
         const allSpecFiles = [];
         for (const td of [...group.test, ...group.cypress]) {
             allSpecFiles.push(...getSpecFiles(td.path));
@@ -343,6 +769,101 @@ export function scanProject(projectRoot) {
             routesGuessed: true,
         });
     }
+    // When a separate testsRoot is provided, discover families from test
+    // directory structure.  Projects with feature-organized tests but
+    // code-type-organized source benefit from this.
+    if (testsRoot) {
+        const testFamilies = discoverTestDerivedFamilies(resolvedTestsRoot);
+        const existingIds = new Set(families.map((f) => f.id));
+        for (const tf of testFamilies) {
+            if (existingIds.has(tf.id)) {
+                // Merge specDirs into existing family
+                const existing = families.find((f) => f.id === tf.id);
+                for (const sd of tf.specDirs) {
+                    if (!existing.specDirs.includes(sd)) {
+                        existing.specDirs.push(sd);
+                    }
+                }
+                existing.tags = [...new Set([...existing.tags, ...tf.tags])];
+            }
+            else {
+                families.push(tf);
+                existingIds.add(tf.id);
+            }
+        }
+    }
+    // When a separate serverRoot is provided, discover families from Go source
+    // filenames across the three-tier backend (api4, app, store).
+    if (serverRoot) {
+        const { multiTierFamilies: serverMulti, singleTierFamilies: serverSingle } = discoverServerDerivedFamilies(resolve(serverRoot));
+        const existingIds = new Set(families.map((f) => f.id));
+        // Merge ALL server families (multi + single tier) into existing families,
+        // but only add NEW families if they span ≥2 tiers.
+        const allServerFamilies = [...serverMulti, ...serverSingle];
+        for (const sf of allServerFamilies) {
+            // Try exact match, then singular/plural variants
+            let target = families.find((f) => f.id === sf.id);
+            if (!target && !sf.id.endsWith('s')) {
+                target = families.find((f) => f.id === sf.id + 's');
+            }
+            if (!target && sf.id.endsWith('s')) {
+                target = families.find((f) => f.id === sf.id.slice(0, -1));
+            }
+            if (target) {
+                // Merge serverPaths into existing family
+                for (const sp of sf.serverPaths) {
+                    if (!target.serverPaths.includes(sp)) {
+                        target.serverPaths.push(sp);
+                    }
+                }
+            }
+            else if (serverMulti.includes(sf)) {
+                // Only add new families if they span ≥2 tiers
+                families.push(sf);
+                existingIds.add(sf.id);
+            }
+        }
+    }
+    // Merge test library paths (page objects, helpers) into existing families
+    if (testsRoot) {
+        const testLibPaths = discoverTestLibPaths(resolvedTestsRoot);
+        for (const [libFamilyId, patterns] of testLibPaths) {
+            let target = families.find((f) => f.id === libFamilyId);
+            if (!target && !libFamilyId.endsWith('s')) {
+                target = families.find((f) => f.id === libFamilyId + 's');
+            }
+            if (!target && libFamilyId.endsWith('s')) {
+                target = families.find((f) => f.id === libFamilyId.slice(0, -1));
+            }
+            if (target) {
+                for (const p of patterns) {
+                    if (!target.webappPaths.includes(p)) {
+                        target.webappPaths.push(p);
+                    }
+                }
+            }
+        }
+    }
+    // Merge name-matched type/util files into existing families
+    {
+        const nameMatchedPaths = discoverNameMatchedPaths(resolved, gitRepoRoot);
+        for (const [nmFamilyId, paths] of nameMatchedPaths) {
+            let target = families.find((f) => f.id === nmFamilyId);
+            if (!target && !nmFamilyId.endsWith('s')) {
+                target = families.find((f) => f.id === nmFamilyId + 's');
+            }
+            if (!target && nmFamilyId.endsWith('s')) {
+                target = families.find((f) => f.id === nmFamilyId.slice(0, -1));
+            }
+            if (target) {
+                for (const p of paths) {
+                    if (!target.webappPaths.includes(p)) {
+                        target.webappPaths.push(p);
+                    }
+                }
+            }
+        }
+    }
     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)));

package/dist/esm/training/validator.js

@@ -3,6 +3,62 @@
 import { execFileSync } from 'child_process';
 import { resolve } from 'path';
 import { bindFilesToFamilies } from '../knowledge/route_families.js';
+/**
+ * Glob-style patterns for infrastructure / cross-cutting files that will never
+ * belong to a single route family.  Excluded from coverage calculations.
+ */
+const INFRA_GLOBS = [
+    'Makefile', 'go.mod', 'go.sum',
+    '*.lock',
+    '**/mocks/*', '**/storetest/*', '**/testlib/*',
+    '**/i18n/*',
+    '**/.github/*', '**/scripts/*',
+    '**/docker-compose*',
+    '**/__fixtures__/*', '**/test_templates/*',
+];
+/**
+ * Check if a file path matches any infrastructure glob pattern.
+ * Uses simple string matching — no external glob library needed.
+ */
+export function isInfraFile(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    for (const pattern of INFRA_GLOBS) {
+        if (pattern.startsWith('**/')) {
+            // Match anywhere in the path
+            const suffix = pattern.slice(3);
+            if (suffix.endsWith('/*')) {
+                // Directory match: **/mocks/* → any segment named "mocks" with a child
+                const dirName = suffix.slice(0, -2);
+                if (normalized.includes(`/${dirName}/`) || normalized.startsWith(`${dirName}/`))
+                    return true;
+            }
+            else if (suffix.endsWith('*')) {
+                // Prefix match: **/docker-compose* → file starting with docker-compose
+                const prefix = suffix.slice(0, -1);
+                const base = normalized.split('/').pop() || '';
+                if (base.startsWith(prefix))
+                    return true;
+            }
+            else {
+                if (normalized.endsWith(`/${suffix}`) || normalized === suffix)
+                    return true;
+            }
+        }
+        else if (pattern.startsWith('*.')) {
+            // Extension match: *.lock
+            const ext = pattern.slice(1);
+            if (normalized.endsWith(ext))
+                return true;
+        }
+        else {
+            // Exact basename match: Makefile, go.mod, go.sum
+            const base = normalized.split('/').pop() || '';
+            if (base === pattern)
+                return true;
+        }
+    }
+    return false;
+}
 export function parseGitLog(log) {
     const commits = [];
     let current = null;
@@ -49,10 +105,10 @@ export function getCommitFiles(projectRoot, since) {
     return parseGitLog(log);
 }
 export function validateCommit(manifest, files, hash, message) {
-    // Filter out non-source files
+    // Filter out non-source files and infrastructure 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/');
+            !f.startsWith('.') && !f.includes('node_modules/') && !isInfraFile(f);
     });
     if (sourceFiles.length === 0) {
         return { hash, message, changedFiles: [], boundFiles: 0, unboundFiles: [], familiesHit: [] };

package/dist/logger.d.ts

@@ -11,12 +11,21 @@ export declare enum LogLevel {
 }
 export declare class Logger {
     private level;
+    private jsonMode;
     constructor(minLevel?: LogLevel);
     error(message: string, context?: Record<string, unknown>): void;
     warn(message: string, context?: Record<string, unknown>): void;
     info(message: string, context?: Record<string, unknown>): void;
     debug(message: string, context?: Record<string, unknown>): void;
     setLevel(level: LogLevel): void;
+    setJsonMode(enabled: boolean): void;
+    /**
+     * Start a timer for measuring duration of an operation.
+     * Returns an object with `end()` that logs at DEBUG level and returns elapsed ms.
+     */
+    timer(label: string): {
+        end: () => number;
+    };
     private log;
 }
 export declare const logger: Logger;

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,oBAAY,QAAQ;IAChB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACZ;AAqCD,qBAAa,MAAM;IACf,OAAO,CAAC,KAAK,CAAW;gBAEZ,QAAQ,CAAC,EAAE,QAAQ;IAI/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B,OAAO,CAAC,GAAG;CAYd;AAGD,eAAO,MAAM,MAAM,QAAe,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,oBAAY,QAAQ;IAChB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACZ;AAqCD,qBAAa,MAAM;IACf,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,QAAQ,CAAU;gBAEd,QAAQ,CAAC,EAAE,QAAQ;IAK/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAInC;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG;QAAC,GAAG,EAAE,MAAM,MAAM,CAAA;KAAC;IAWzC,OAAO,CAAC,GAAG;CAoBd;AAGD,eAAO,MAAM,MAAM,QAAe,CAAC"}