@yasserkhanorg/impact-gate 2.0.0

package/dist/agent/traceability_capture.js

@@ -0,0 +1,313 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureTraceabilityInput = captureTraceabilityInput;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const git_js_1 = require("./git.js");
+const utils_js_1 = require("./utils.js");
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function resolveFilePath(cwd, value) {
+    if ((0, path_1.isAbsolute)(value)) {
+        return value;
+    }
+    return (0, path_1.resolve)(cwd, value);
+}
+function normalizeList(values) {
+    return Array.from(new Set(values
+        .map((value) => (0, utils_js_1.normalizePath)(value))
+        .filter(Boolean)));
+}
+function parseStringArray(value) {
+    return normalizeList(asArray(value)
+        .filter((item) => typeof item === 'string')
+        .map((item) => item));
+}
+function isExecutedStatus(status) {
+    return status !== 'skipped';
+}
+function specExecuted(spec) {
+    const tests = asArray(spec.tests);
+    if (tests.length === 0) {
+        return false;
+    }
+    for (const testValue of tests) {
+        const testNode = asRecord(testValue);
+        if (!testNode) {
+            continue;
+        }
+        const testStatus = typeof testNode.status === 'string' ? testNode.status : undefined;
+        if (testStatus && isExecutedStatus(testStatus)) {
+            return true;
+        }
+        const outcome = typeof testNode.outcome === 'string' ? testNode.outcome : undefined;
+        if (outcome && isExecutedStatus(outcome)) {
+            return true;
+        }
+        const results = asArray(testNode.results);
+        for (const resultValue of results) {
+            const resultNode = asRecord(resultValue);
+            if (!resultNode) {
+                continue;
+            }
+            const status = typeof resultNode.status === 'string' ? resultNode.status : undefined;
+            if (status && isExecutedStatus(status)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function relativizePath(path, roots) {
+    const normalized = (0, utils_js_1.normalizePath)(path);
+    for (const root of roots) {
+        const normalizedRoot = (0, utils_js_1.normalizePath)((0, path_1.resolve)(root));
+        if (normalized === normalizedRoot) {
+            return '.';
+        }
+        if (normalized.startsWith(`${normalizedRoot}/`)) {
+            return normalized.slice(normalizedRoot.length + 1);
+        }
+    }
+    return normalized;
+}
+function collectExecutedSpecs(value, roots, output) {
+    const node = asRecord(value);
+    if (!node) {
+        return;
+    }
+    const specs = asArray(node.specs);
+    for (const specValue of specs) {
+        const specNode = asRecord(specValue);
+        if (!specNode) {
+            continue;
+        }
+        const file = typeof specNode.file === 'string' ? specNode.file : '';
+        if (!file) {
+            continue;
+        }
+        if (!specExecuted(specNode)) {
+            continue;
+        }
+        output.add(relativizePath(file, roots));
+    }
+    const suites = asArray(node.suites);
+    for (const suite of suites) {
+        collectExecutedSpecs(suite, roots, output);
+    }
+}
+function loadPlaywrightExecutedSpecs(reportPath, roots) {
+    const raw = JSON.parse((0, fs_1.readFileSync)(reportPath, 'utf-8'));
+    const specs = new Set();
+    collectExecutedSpecs(raw, roots, specs);
+    return Array.from(specs).sort();
+}
+function loadChangedFilesFromPath(filePath) {
+    const rawText = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const trimmed = rawText.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return normalizeList(parsed.filter((value) => typeof value === 'string'));
+        }
+        const node = asRecord(parsed);
+        if (!node) {
+            return [];
+        }
+        if (Array.isArray(node.files)) {
+            return normalizeList(node.files.filter((value) => typeof value === 'string'));
+        }
+        if (Array.isArray(node.changedFiles)) {
+            return normalizeList(node.changedFiles.filter((value) => typeof value === 'string'));
+        }
+        return [];
+    }
+    return normalizeList(rawText
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean));
+}
+function addCoverageEntry(map, test, files) {
+    if (!test || files.length === 0) {
+        return;
+    }
+    const normalizedTest = (0, utils_js_1.normalizePath)(test);
+    if (!map.has(normalizedTest)) {
+        map.set(normalizedTest, new Set());
+    }
+    const bucket = map.get(normalizedTest);
+    for (const file of files) {
+        bucket?.add((0, utils_js_1.normalizePath)(file));
+    }
+}
+function loadCoverageMap(path) {
+    const raw = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+    const map = new Map();
+    const appendTestEntry = (testValue, filesValue) => {
+        if (typeof testValue !== 'string') {
+            return;
+        }
+        const files = parseStringArray(filesValue);
+        addCoverageEntry(map, testValue, files);
+    };
+    if (Array.isArray(raw)) {
+        for (const entry of raw) {
+            const node = asRecord(entry);
+            if (!node) {
+                continue;
+            }
+            appendTestEntry(node.test, node.touchedFiles);
+        }
+        return map;
+    }
+    const node = asRecord(raw);
+    if (!node) {
+        return map;
+    }
+    for (const entry of asArray(node.tests)) {
+        const testNode = asRecord(entry);
+        if (!testNode) {
+            continue;
+        }
+        appendTestEntry(testNode.test, Array.isArray(testNode.touchedFiles) ? testNode.touchedFiles : testNode.files);
+    }
+    for (const entry of asArray(node.runs)) {
+        const runNode = asRecord(entry);
+        if (!runNode) {
+            continue;
+        }
+        const files = Array.isArray(runNode.touchedFiles)
+            ? runNode.touchedFiles
+            : (Array.isArray(runNode.coveredFiles) ? runNode.coveredFiles : runNode.files);
+        appendTestEntry(runNode.test, files);
+    }
+    const mappings = asArray(node.mappings);
+    for (const mapping of mappings) {
+        const mappingNode = asRecord(mapping);
+        if (!mappingNode || typeof mappingNode.file !== 'string' || !Array.isArray(mappingNode.tests)) {
+            continue;
+        }
+        const normalizedFile = (0, utils_js_1.normalizePath)(mappingNode.file);
+        for (const test of mappingNode.tests) {
+            if (typeof test !== 'string') {
+                continue;
+            }
+            addCoverageEntry(map, test, [normalizedFile]);
+        }
+    }
+    const fileToTests = asRecord(node.fileToTests);
+    if (fileToTests) {
+        for (const [file, tests] of Object.entries(fileToTests)) {
+            if (!Array.isArray(tests)) {
+                continue;
+            }
+            for (const test of tests) {
+                if (typeof test !== 'string') {
+                    continue;
+                }
+                addCoverageEntry(map, test, [(0, utils_js_1.normalizePath)(file)]);
+            }
+        }
+    }
+    return map;
+}
+function coverageForSpec(specPath, coverageMap) {
+    const normalizedSpec = (0, utils_js_1.normalizePath)(specPath);
+    const files = new Set();
+    const direct = coverageMap.get(normalizedSpec);
+    if (direct) {
+        for (const file of direct) {
+            files.add(file);
+        }
+    }
+    const prefix = `${normalizedSpec}#`;
+    for (const [key, value] of coverageMap.entries()) {
+        if (key.startsWith(prefix)) {
+            for (const file of value) {
+                files.add(file);
+            }
+        }
+    }
+    return Array.from(files).sort();
+}
+function captureTraceabilityInput(options) {
+    const warnings = [];
+    const reportPath = resolveFilePath(process.cwd(), options.reportPath);
+    if (!(0, fs_1.existsSync)(reportPath)) {
+        throw new Error(`Traceability report not found: ${reportPath}`);
+    }
+    const roots = [options.testsRoot, options.appPath].map((root) => (0, path_1.resolve)(root));
+    const executedSpecs = loadPlaywrightExecutedSpecs(reportPath, roots);
+    if (executedSpecs.length === 0) {
+        warnings.push('No executed tests found in Playwright report.');
+    }
+    let changedFiles = [];
+    if (options.changedFilesPath) {
+        const changedPath = resolveFilePath(process.cwd(), options.changedFilesPath);
+        if ((0, fs_1.existsSync)(changedPath)) {
+            changedFiles = loadChangedFilesFromPath(changedPath);
+        }
+        else {
+            warnings.push(`Changed files path not found: ${changedPath}`);
+        }
+    }
+    else {
+        const diff = (0, git_js_1.getChangedFiles)(options.appPath, options.sinceRef, { includeUncommitted: false });
+        if (diff.error) {
+            warnings.push(`Git diff failed while building traceability input: ${diff.error}`);
+        }
+        changedFiles = diff.files;
+    }
+    changedFiles = normalizeList(changedFiles);
+    let coverageMap = new Map();
+    if (options.coverageMapPath) {
+        const coveragePath = resolveFilePath(process.cwd(), options.coverageMapPath);
+        if ((0, fs_1.existsSync)(coveragePath)) {
+            coverageMap = loadCoverageMap(coveragePath);
+        }
+        else {
+            warnings.push(`Coverage map path not found: ${coveragePath}`);
+        }
+    }
+    const runs = executedSpecs.map((spec) => {
+        const mappedFiles = coverageForSpec(spec, coverageMap);
+        const touchedFiles = mappedFiles.length > 0 ? mappedFiles : changedFiles;
+        return {
+            test: spec,
+            touchedFiles,
+            timestamp: new Date().toISOString(),
+        };
+    }).filter((entry) => entry.touchedFiles.length > 0);
+    if (runs.length < executedSpecs.length && changedFiles.length === 0) {
+        warnings.push('Some executed tests had no coverage-map entries and no changed-files fallback.');
+    }
+    const outputPath = options.outputPath
+        ? resolveFilePath(process.cwd(), options.outputPath)
+        : (0, path_1.resolve)(options.testsRoot, '.e2e-ai-agents', 'traceability-input.json');
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(outputPath), { recursive: true });
+    (0, fs_1.writeFileSync)(outputPath, JSON.stringify({
+        schemaVersion: '1.0.0',
+        source: 'traceability-capture',
+        generatedAt: new Date().toISOString(),
+        runs,
+    }, null, 2), 'utf-8');
+    return {
+        outputPath,
+        testsSeen: executedSpecs.length,
+        runsGenerated: runs.length,
+        changedFilesUsed: changedFiles.length,
+        warnings,
+    };
+}

package/dist/agent/traceability_ingest.d.ts

@@ -0,0 +1,21 @@
+import type { TraceabilityImpactConfig } from './config.js';
+export interface TraceabilityIngestEntry {
+    test: string;
+    touchedFiles: string[];
+    timestamp?: string;
+}
+export interface TraceabilityIngestOptions {
+    minHits?: number;
+    maxFilesPerTest?: number;
+    maxAgeDays?: number;
+}
+export interface TraceabilityIngestResult {
+    manifestPath: string;
+    statePath: string;
+    entriesIngested: number;
+    testsTracked: number;
+    edgesTracked: number;
+    warnings: string[];
+}
+export declare function ingestTraceabilityInput(rootPath: string, traceabilityConfig: TraceabilityImpactConfig, inputPayload: unknown, options?: TraceabilityIngestOptions): TraceabilityIngestResult;
+//# sourceMappingURL=traceability_ingest.d.ts.map

package/dist/agent/traceability_ingest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceability_ingest.d.ts","sourceRoot":"","sources":["../../src/agent/traceability_ingest.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,aAAa,CAAC;AAG1D,MAAM,WAAW,uBAAuB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAgCD,MAAM,WAAW,wBAAwB;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AA4MD,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,wBAAwB,EAC5C,YAAY,EAAE,OAAO,EACrB,OAAO,CAAC,EAAE,yBAAyB,GACpC,wBAAwB,CAoE1B"}

package/dist/agent/traceability_ingest.js

@@ -0,0 +1,237 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ingestTraceabilityInput = ingestTraceabilityInput;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const utils_js_1 = require("./utils.js");
+const DEFAULT_OPTIONS = {
+    minHits: 1,
+    maxFilesPerTest: 200,
+    maxAgeDays: 120,
+};
+function resolvePath(root, value) {
+    if ((0, path_1.isAbsolute)(value)) {
+        return value;
+    }
+    return (0, path_1.join)(root, value);
+}
+function parseDate(value) {
+    const parsed = Date.parse(value);
+    if (Number.isNaN(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+function safeReadJson(path) {
+    if (!(0, fs_1.existsSync)(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeFiles(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return Array.from(new Set(value
+        .filter((entry) => typeof entry === 'string')
+        .map((entry) => (0, utils_js_1.normalizePath)(entry))));
+}
+function normalizeTest(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = (0, utils_js_1.normalizePath)(value);
+    return normalized ? normalized : null;
+}
+function buildEntriesFromInput(payload) {
+    const warnings = [];
+    const entries = [];
+    const pushEntry = (testValue, filesValue, timestampValue) => {
+        const test = normalizeTest(testValue);
+        const files = normalizeFiles(filesValue);
+        if (!test || files.length === 0) {
+            return;
+        }
+        entries.push({
+            test,
+            touchedFiles: files,
+            timestamp: typeof timestampValue === 'string' ? timestampValue : undefined,
+        });
+    };
+    if (Array.isArray(payload)) {
+        for (const item of payload) {
+            if (!item || typeof item !== 'object') {
+                continue;
+            }
+            const entry = item;
+            pushEntry(entry.test, entry.touchedFiles, entry.timestamp);
+        }
+        if (entries.length === 0) {
+            warnings.push('Traceability input array had no valid entries.');
+        }
+        return { entries, warnings };
+    }
+    if (!payload || typeof payload !== 'object') {
+        warnings.push('Traceability input must be an object or array.');
+        return { entries, warnings };
+    }
+    const input = payload;
+    if (Array.isArray(input.tests)) {
+        for (const item of input.tests) {
+            pushEntry(item?.test, item?.touchedFiles, item?.timestamp);
+        }
+    }
+    if (Array.isArray(input.runs)) {
+        for (const item of input.runs) {
+            const files = Array.isArray(item?.touchedFiles) ? item?.touchedFiles : (Array.isArray(item?.coveredFiles) ? item?.coveredFiles : item?.files);
+            pushEntry(item?.test, files, item?.timestamp);
+        }
+    }
+    if (input.fileToTests && typeof input.fileToTests === 'object') {
+        for (const [file, tests] of Object.entries(input.fileToTests)) {
+            if (!Array.isArray(tests)) {
+                continue;
+            }
+            const normalizedFile = (0, utils_js_1.normalizePath)(file);
+            for (const test of tests) {
+                pushEntry(test, [normalizedFile]);
+            }
+        }
+    }
+    if (Array.isArray(input.mappings)) {
+        for (const mapping of input.mappings) {
+            const file = typeof mapping?.file === 'string' ? (0, utils_js_1.normalizePath)(mapping.file) : null;
+            if (!file || !Array.isArray(mapping.tests)) {
+                continue;
+            }
+            for (const test of mapping.tests) {
+                pushEntry(test, [file]);
+            }
+        }
+    }
+    if (entries.length === 0) {
+        warnings.push('Traceability input had no valid test<->file entries.');
+    }
+    return { entries, warnings };
+}
+function defaultState() {
+    return {
+        schemaVersion: '1.0.0',
+        updatedAt: new Date().toISOString(),
+        tests: {},
+    };
+}
+function loadState(path) {
+    const existing = safeReadJson(path);
+    if (!existing || typeof existing !== 'object' || !existing.tests) {
+        return defaultState();
+    }
+    return {
+        schemaVersion: '1.0.0',
+        updatedAt: existing.updatedAt || new Date().toISOString(),
+        tests: existing.tests,
+    };
+}
+function pruneByAge(state, maxAgeDays) {
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    for (const [test, entry] of Object.entries(state.tests)) {
+        const lastSeen = parseDate(entry.lastSeen);
+        if (lastSeen === null) {
+            continue;
+        }
+        if (lastSeen < cutoff) {
+            delete state.tests[test];
+        }
+    }
+}
+function buildManifest(state, minHits, maxFilesPerTest) {
+    const tests = Object.entries(state.tests)
+        .map(([test, entry]) => {
+        const touchedFiles = Object.entries(entry.files)
+            .filter(([, hits]) => hits >= minHits)
+            .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+            .slice(0, maxFilesPerTest)
+            .map(([file]) => file);
+        const signalCount = Object.values(entry.files).reduce((acc, value) => acc + value, 0);
+        return {
+            test,
+            touchedFiles,
+            signalCount,
+            lastSeen: entry.lastSeen,
+        };
+    })
+        .filter((entry) => entry.touchedFiles.length > 0)
+        .sort((a, b) => a.test.localeCompare(b.test));
+    return {
+        schemaVersion: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        tests,
+    };
+}
+function ensureParent(path) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(path), { recursive: true });
+}
+function ingestTraceabilityInput(rootPath, traceabilityConfig, inputPayload, options) {
+    const resolvedOptions = {
+        minHits: options?.minHits ?? DEFAULT_OPTIONS.minHits,
+        maxFilesPerTest: options?.maxFilesPerTest ?? DEFAULT_OPTIONS.maxFilesPerTest,
+        maxAgeDays: options?.maxAgeDays ?? DEFAULT_OPTIONS.maxAgeDays,
+    };
+    const warnings = [];
+    const manifestPath = resolvePath(rootPath, traceabilityConfig.manifestPath);
+    const statePath = (0, path_1.join)((0, path_1.dirname)(manifestPath), 'traceability-state.json');
+    if (!traceabilityConfig.enabled) {
+        warnings.push('Traceability is disabled in config. Input was not ingested.');
+        return {
+            manifestPath,
+            statePath,
+            entriesIngested: 0,
+            testsTracked: 0,
+            edgesTracked: 0,
+            warnings,
+        };
+    }
+    const parsed = buildEntriesFromInput(inputPayload);
+    warnings.push(...parsed.warnings);
+    const state = loadState(statePath);
+    const now = new Date().toISOString();
+    for (const entry of parsed.entries) {
+        const bucket = state.tests[entry.test] || {
+            files: {},
+            seenCount: 0,
+            lastSeen: now,
+        };
+        bucket.seenCount += 1;
+        bucket.lastSeen = entry.timestamp || now;
+        for (const file of entry.touchedFiles) {
+            bucket.files[file] = (bucket.files[file] || 0) + 1;
+        }
+        state.tests[entry.test] = bucket;
+    }
+    pruneByAge(state, Math.max(1, resolvedOptions.maxAgeDays));
+    state.updatedAt = now;
+    const manifest = buildManifest(state, Math.max(1, resolvedOptions.minHits), Math.max(1, resolvedOptions.maxFilesPerTest));
+    let edgesTracked = 0;
+    for (const entry of manifest.tests) {
+        edgesTracked += entry.touchedFiles.length;
+    }
+    ensureParent(statePath);
+    ensureParent(manifestPath);
+    (0, fs_1.writeFileSync)(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    (0, fs_1.writeFileSync)(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    return {
+        manifestPath,
+        statePath,
+        entriesIngested: parsed.entries.length,
+        testsTracked: manifest.tests.length,
+        edgesTracked,
+        warnings,
+    };
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared types extracted from the legacy analysis module.
+ * Kept for backward compatibility with pipeline and plan systems.
+ */
+import type { AudienceRole, FlagState } from './config.js';
+export type FlowPriority = 'P0' | 'P1' | 'P2';
+export type FlagSource = 'featureFlag' | 'configFlag' | 'testGate';
+export interface FlagHit {
+    name: string;
+    source: FlagSource;
+    defaultState: FlagState;
+}
+export interface BlastRadius {
+    audience: AudienceRole[];
+    flags: FlagHit[];
+    summary: string;
+    scoreDelta: number;
+}
+export interface FlowImpact {
+    id: string;
+    name: string;
+    kind: 'screen' | 'flow';
+    score: number;
+    priority: FlowPriority;
+    reasons: string[];
+    keywords: string[];
+    files: string[];
+    audience?: AudienceRole[];
+    flags?: FlagHit[];
+    blastRadius?: BlastRadius;
+    priorityFloor?: FlowPriority;
+    subsystemRiskBoost?: number;
+    subsystemRiskRules?: string[];
+    existingTests?: string[];
+    missingScenarios?: string[];
+}
+export interface FlowCoverage {
+    flowId: string;
+    flowName: string;
+    coveredBy: string[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/agent/types.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,OAAO,KAAK,EAAC,YAAY,EAAE,SAAS,EAAC,MAAM,aAAa,CAAC;AAEzD,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,YAAY,GAAG,UAAU,CAAC;AAEnE,MAAM,WAAW,OAAO;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,EAAE,SAAS,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW;IACxB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;CACvB"}

package/dist/agent/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent/utils.d.ts

@@ -0,0 +1,13 @@
+export declare function hasGlobChars(value: string): boolean;
+export declare function globToRegExp(pattern: string): RegExp;
+export declare function matchGlob(pathValue: string, pattern: string): boolean;
+export declare function safeReadTextFile(path: string): string | null;
+export declare function normalizePath(pathValue: string): string;
+export declare function toRelativePosix(root: string, filePath: string): string;
+export declare function isPathWithinRoot(root: string, target: string): boolean;
+export declare function fileExtension(pathValue: string): string;
+export declare function baseNameWithoutExt(pathValue: string): string;
+export declare function tokenize(value: string): string[];
+export declare function uniqueTokens(tokens: string[]): string[];
+export declare function titleCase(value: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/agent/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/agent/utils.ts"],"names":[],"mappings":"AAuCA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA+BpD;AAED,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAWrE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU5D;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGtE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAKtE;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAI5D;AAMD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAUhD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEvD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM/C"}