@eventra_dev/eventra-cli 0.3.5 → 0.3.9

package/dist/analysis/engine/analyzeFile.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexSourceFile = indexSourceFile;
+exports.extractFromIndex = extractFromIndex;
+const scanner_1 = require("../scanner/scanner");
+const extractor_1 = require("../extractor/extractor");
+function indexSourceFile(source, checker, wrapperRegistry) {
+    return (0, scanner_1.scanSource)(source, checker, wrapperRegistry);
+}
+function extractFromIndex(index, config, checker, wrapperRegistry, evaluationCache, resolvedCallCache, returnPropagationCache, resolvedExportCache) {
+    return (0, extractor_1.extractEvents)(index, checker, config, evaluationCache, resolvedExportCache, resolvedCallCache, returnPropagationCache, wrapperRegistry);
+}

package/dist/analysis/resolver/callResolver.js

@@ -22,6 +22,10 @@ function resolveDeclaration(declaration) {
     if (typescript_1.default.isPropertyDeclaration(declaration) && declaration.initializer && isFunctionLike(declaration.initializer)) {
         return declaration.initializer;
     }
+    // { trackFeature() {} }
+    if (typescript_1.default.isPropertyAssignment(declaration) && declaration.initializer && isFunctionLike(declaration.initializer)) {
+        return declaration.initializer;
+    }
     return null;
 }
 function getExpressionSymbol(expression, checker) {

package/dist/analysis/resolver/exportResolver.js

@@ -16,6 +16,9 @@ function isConcreteDeclaration(node) {
         || typescript_1.default.isPropertyDeclaration(node));
 }
 function resolveExportedSymbol(symbol, checker, cache, visited) {
+    if (typeof symbol.getDeclarations !== "function") {
+        return null;
+    }
     const seen = visited ?? new Set();
     const cached = cache.get(symbol);
     if (cached !== undefined) {

package/dist/analysis/symbols/wrapperRegistry.js

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WrapperRegistry = void 0;
-const typescript_1 = __importDefault(require("typescript"));
 const exportResolver_1 = require("../resolver/exportResolver");
+const symbolUtils_1 = require("./symbolUtils");
 function isSymbol(value) {
-    return "flags" in value;
+    return typeof value.getDeclarations === "function";
 }
 class WrapperRegistry {
     checker;
@@ -17,6 +14,12 @@ class WrapperRegistry {
         this.checker = checker;
         this.exportCache = exportCache;
     }
+    setChecker(checker) {
+        this.checker = checker;
+    }
+    getChecker() {
+        return this.checker;
+    }
     normalize(symbol) {
         return ((0, exportResolver_1.resolveExportedSymbol)(symbol, this.checker, this.exportCache) ?? symbol);
     }
@@ -27,16 +30,7 @@ class WrapperRegistry {
         if (isSymbol(target)) {
             return this.wrappers.get(this.normalize(target));
         }
-        let symbol;
-        if (typescript_1.default.isFunctionDeclaration(target) && target.name) {
-            symbol = this.checker.getSymbolAtLocation(target.name);
-        }
-        else if (typescript_1.default.isMethodDeclaration(target) && typescript_1.default.isIdentifier(target.name)) {
-            symbol = this.checker.getSymbolAtLocation(target.name);
-        }
-        else if (target.parent && typescript_1.default.isVariableDeclaration(target.parent) && typescript_1.default.isIdentifier(target.parent.name)) {
-            symbol = this.checker.getSymbolAtLocation(target.parent.name);
-        }
+        const symbol = (0, symbolUtils_1.getFunctionSymbol)(target, this.checker);
         if (!symbol) {
             return undefined;
         }

package/dist/cli/check.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -40,31 +7,46 @@ exports.check = check;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config/config");
 const projectScanner_1 = require("../core/projectScanner");
+const scanResults_1 = require("../core/scanResults");
+function diffSets(found, known) {
+    return {
+        added: [...found].filter((e) => !known.has(e)),
+        removed: [...known].filter((e) => !found.has(e)),
+    };
+}
 async function check({ fix = false }) {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
         console.log(chalk_1.default.red("eventra.json not found"));
         process.exit(1);
     }
-    console.log(chalk_1.default.blue("Checking events..."));
+    console.log(chalk_1.default.blue("Checking events and function wrappers..."));
     const { engine } = await (0, projectScanner_1.scanProject)(config);
-    const found = new Set(engine.getAllEvents());
-    const known = new Set(config.events ?? []);
-    const added = [...found].filter(e => !known.has(e));
-    const removed = [...known].filter(e => !found.has(e));
+    const foundEvents = new Set(engine.getAllEvents());
+    const knownEvents = new Set(config.events ?? []);
+    const eventDiff = diffSets(foundEvents, knownEvents);
+    const foundWrappers = new Set(engine.getAllFunctionWrappers());
+    const knownWrappers = new Set(config.functionWrappers?.map((w) => w.name) ?? []);
+    const wrapperDiff = diffSets(foundWrappers, knownWrappers);
     if (fix) {
-        const nextConfig = {
-            ...config,
-            events: [...found].sort(),
-        };
-        const { saveConfig } = await Promise.resolve().then(() => __importStar(require("../config/config")));
-        await saveConfig(nextConfig);
+        await (0, config_1.saveConfig)((0, scanResults_1.buildConfigFromScan)(config, engine));
         console.log(chalk_1.default.green("Synced"));
         return;
     }
-    if (added.length || removed.length) {
-        added.forEach(e => console.log(chalk_1.default.red(`+ ${e}`)));
-        removed.forEach(e => console.log(chalk_1.default.yellow(`- ${e}`)));
+    let hasDiff = false;
+    if (eventDiff.added.length || eventDiff.removed.length) {
+        hasDiff = true;
+        console.log(chalk_1.default.blue("\nEvents:"));
+        eventDiff.added.forEach((e) => console.log(chalk_1.default.red(`+ ${e}`)));
+        eventDiff.removed.forEach((e) => console.log(chalk_1.default.yellow(`- ${e}`)));
+    }
+    if (wrapperDiff.added.length || wrapperDiff.removed.length) {
+        hasDiff = true;
+        console.log(chalk_1.default.blue("\nFunction wrappers:"));
+        wrapperDiff.added.forEach((w) => console.log(chalk_1.default.red(`+ ${w}`)));
+        wrapperDiff.removed.forEach((w) => console.log(chalk_1.default.yellow(`- ${w}`)));
+    }
+    if (hasDiff) {
         process.exit(1);
     }
     console.log(chalk_1.default.green("All good"));

package/dist/cli/init.js

@@ -34,6 +34,7 @@ async function init() {
         apiKey,
         endpoint,
         events: [],
+        functionWrappers: [],
         sync: {
             include: [
                 "**/*.{ts,tsx,js,jsx}",

package/dist/cli/sync.js

@@ -7,6 +7,7 @@ exports.sync = sync;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config/config");
 const projectScanner_1 = require("../core/projectScanner");
+const scanResults_1 = require("../core/scanResults");
 async function sync() {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
@@ -15,7 +16,8 @@ async function sync() {
     }
     console.log(chalk_1.default.blue("Scanning..."));
     const { engine } = await (0, projectScanner_1.scanProject)(config);
-    const events = engine.getAllEvents().sort();
-    await (0, config_1.saveConfig)({ ...config, events });
-    console.log(chalk_1.default.green(`Found ${events.length} events`));
+    await (0, scanResults_1.persistScanResults)(config, engine);
+    const events = engine.getAllEvents();
+    const wrappers = engine.getAllFunctionWrappers();
+    console.log(chalk_1.default.green(`Found ${events.length} events, ${wrappers.length} function wrappers`));
 }

package/dist/cli/watch.js

@@ -11,6 +11,7 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../config/config");
 const EventraEngine_1 = require("../core/EventraEngine");
+const scanResults_1 = require("../core/scanResults");
 const processFile_1 = require("../filesystem/processFile");
 const getVirtualFile_1 = require("../filesystem/getVirtualFile");
 async function watch() {
@@ -24,10 +25,10 @@ async function watch() {
     const fileDeps = new Map();
     const cache = new Map();
     const watchedDeps = new Set();
+    const trackedFiles = new Set();
     const normalize = (file) => {
         return path_1.default.resolve(file).replace(/\\/g, "/");
     };
-    // INITIAL LOAD
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
         absolute: true,
@@ -39,23 +40,21 @@ async function watch() {
             const raw = await promises_1.default.readFile(abs, "utf-8");
             const parsed = await (0, processFile_1.processFile)(abs, raw);
             cache.set(abs, parsed);
+            trackedFiles.add(abs);
             await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content);
-            await engine.updateFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content, config);
-            fileDeps.set(abs, new Set(parsed.dependencies.map(dep => normalize(dep))));
+            fileDeps.set(abs, new Set(parsed.dependencies.map((dep) => normalize(path_1.default.resolve(path_1.default.dirname(abs), dep)))));
         }
         catch {
             // ignore invalid files
         }
     }
     engine.endPreload();
-    const initialEvents = engine.getAllEvents().sort();
-    await (0, config_1.saveConfig)({
-        ...config,
-        events: initialEvents,
-    });
-    console.log(chalk_1.default.gray(`Initial: ${initialEvents.length}\n`));
-    // WATCHER
-    const watcher = chokidar_1.default.watch([...files.map(normalize), ...watchedDeps], { ignoreInitial: true });
+    await engine.runFullAnalysis([...trackedFiles].map((f) => (0, getVirtualFile_1.getVirtualFile)(f)), config);
+    await (0, scanResults_1.persistScanResults)(config, engine);
+    const initialEvents = engine.getAllEvents();
+    const initialWrappers = engine.getAllFunctionWrappers();
+    console.log(chalk_1.default.gray(`Initial: ${initialEvents.length} events, ${initialWrappers.length} wrappers\n`));
+    const watcher = chokidar_1.default.watch([...trackedFiles, ...watchedDeps], { ignoreInitial: true });
     const queue = new Map();
     let timer = null;
     const run = async () => {
@@ -66,24 +65,20 @@ async function watch() {
                 const raw = await promises_1.default.readFile(file, "utf-8");
                 const parsed = await (0, processFile_1.processFile)(file, raw);
                 cache.set(file, parsed);
+                trackedFiles.add(file);
                 await engine.updateFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content, config);
-                // dependency diff
                 const abs = normalize(file);
                 const prevDeps = fileDeps.get(abs) ?? new Set();
-                const nextDeps = new Set(parsed.dependencies.map(dep => normalize(dep)));
-                // add deps
+                const nextDeps = new Set(parsed.dependencies.map((dep) => normalize(path_1.default.resolve(path_1.default.dirname(abs), dep))));
                 for (const dep of nextDeps) {
-                    if (prevDeps.has(dep)) {
+                    if (prevDeps.has(dep))
                         continue;
-                    }
                     watcher.add(dep);
                     watchedDeps.add(dep);
                 }
-                // remove deps
                 for (const dep of prevDeps) {
-                    if (nextDeps.has(dep)) {
+                    if (nextDeps.has(dep))
                         continue;
-                    }
                     watcher.unwatch(dep);
                     watchedDeps.delete(dep);
                 }
@@ -93,19 +88,14 @@ async function watch() {
                 console.log(chalk_1.default.gray(`skip: ${file}`));
             }
         }
-        const nextEvents = engine.getAllEvents().sort();
-        await (0, config_1.saveConfig)({
-            ...config,
-            events: nextEvents,
-        });
-        console.log(chalk_1.default.green(`Updated: ${nextEvents.length}`));
+        await (0, scanResults_1.persistScanResults)(config, engine);
+        console.log(chalk_1.default.green(`Updated: ${engine.getAllEvents().length} events, ${engine.getAllFunctionWrappers().length} wrappers`));
     };
     const schedule = (file) => {
         const abs = normalize(file);
         queue.set(abs, true);
-        if (timer) {
+        if (timer)
             clearTimeout(timer);
-        }
         timer = setTimeout(run, 200);
     };
     watcher
@@ -113,13 +103,10 @@ async function watch() {
         .on("add", schedule)
         .on("unlink", async (file) => {
         const abs = normalize(file);
+        trackedFiles.delete(abs);
         await engine.removeFile((0, getVirtualFile_1.getVirtualFile)(abs), config);
-        const nextEvents = engine.getAllEvents().sort();
-        await (0, config_1.saveConfig)({
-            ...config,
-            events: nextEvents,
-        });
-        console.log(chalk_1.default.red(`Removed → ${nextEvents.length}`));
+        await (0, scanResults_1.persistScanResults)(config, engine);
+        console.log(chalk_1.default.red(`Removed → ${engine.getAllEvents().length} events, ${engine.getAllFunctionWrappers().length} wrappers`));
     });
     process.on("SIGINT", async () => {
         await watcher.close();

package/dist/compiler/compilerContext.js

@@ -14,11 +14,12 @@ class CompilerContext {
     registry = new documentRegistry_1.DocumentRegistry();
     compilerOptions;
     host;
-    builder;
+    program = typescript_1.default.createProgram([], {});
     rootNames = new Set();
     constructor(rootDir) {
         this.rootDir = rootDir;
-        const configPath = typescript_1.default.findConfigFile(rootDir, typescript_1.default.sys.fileExists, "tsconfig.json");
+        const localTsconfig = path_1.default.join(rootDir, "tsconfig.json");
+        const configPath = fs_1.default.existsSync(localTsconfig) ? localTsconfig : undefined;
         let compilerOptions = {
             target: typescript_1.default.ScriptTarget.ESNext,
             module: typescript_1.default.ModuleKind.ESNext,
@@ -33,7 +34,7 @@ class CompilerContext {
             esModuleInterop: true,
             resolveJsonModule: true,
             allowNonTsExtensions: true,
-            incremental: true,
+            incremental: false,
         };
         if (configPath) {
             const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
@@ -52,30 +53,59 @@ class CompilerContext {
         this.compilerOptions = compilerOptions;
         this.host = typescript_1.default.createCompilerHost(this.compilerOptions, true);
         this.patchCompilerHost();
-        this.builder = typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram([...this.rootNames], this.compilerOptions, this.host);
+        this.rebuildProgram();
     }
     normalize(fileName) {
         return this.registry.normalize(fileName);
     }
+    resolveLanguageVersion(languageVersionOrOptions) {
+        if (typeof languageVersionOrOptions === "object") {
+            return languageVersionOrOptions.languageVersion;
+        }
+        return languageVersionOrOptions;
+    }
+    attachVersion(sourceFile, fileName) {
+        const normalized = this.normalize(fileName);
+        sourceFile.version =
+            this.registry.getVersion(normalized);
+        return sourceFile;
+    }
+    createSourceFileFromRegistry(fileName, languageVersion) {
+        const normalized = this.normalize(fileName);
+        const snapshot = this.registry.getSnapshot(normalized);
+        if (!snapshot) {
+            return undefined;
+        }
+        const sourceFile = typescript_1.default.createSourceFile(normalized, snapshot.getText(0, snapshot.getLength()), languageVersion, true, this.getScriptKind(normalized));
+        return this.attachVersion(sourceFile, normalized);
+    }
     patchCompilerHost() {
-        const originalGetSourceFile = this.host.getSourceFile;
-        this.host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+        const originalGetSourceFile = this.host.getSourceFile.bind(this.host);
+        this.host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+            const languageVersion = this.resolveLanguageVersion(languageVersionOrOptions);
             const normalized = this.normalize(fileName);
             this.registry.ensure(normalized);
-            const snapshot = this.registry.getSnapshot(normalized);
-            if (!snapshot) {
-                return originalGetSourceFile(normalized, languageVersion, onError, shouldCreateNewSourceFile);
+            const fromRegistry = this.createSourceFileFromRegistry(normalized, languageVersion);
+            if (fromRegistry) {
+                return fromRegistry;
+            }
+            const fromDisk = originalGetSourceFile(normalized, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            if (!fromDisk) {
+                return undefined;
+            }
+            if (!this.registry.has(normalized)) {
+                this.registry.update(normalized, fromDisk.getFullText());
             }
-            return typescript_1.default.createSourceFile(normalized, snapshot.getText(0, snapshot.getLength()), languageVersion, true, this.getScriptKind(normalized));
+            return this.attachVersion(fromDisk, normalized);
         };
         this.host.readFile = (fileName) => {
             const normalized = this.normalize(fileName);
             this.registry.ensure(normalized);
-            return (this.registry.getContent(normalized) ?? fs_1.default.readFileSync(normalized, "utf8"));
+            return this.registry.getContent(normalized) ?? fs_1.default.readFileSync(normalized, "utf8");
         };
         this.host.fileExists = (fileName) => {
             const normalized = this.normalize(fileName);
-            return (this.registry.has(normalized) || fs_1.default.existsSync(normalized));
+            return this.registry.has(normalized) || fs_1.default.existsSync(normalized);
         };
         this.host.getCanonicalFileName = (f) => this.normalize(f);
         this.host.useCaseSensitiveFileNames = () => true;
@@ -83,64 +113,62 @@ class CompilerContext {
         this.host.getNewLine = () => "\n";
     }
     getScriptKind(fileName) {
-        if (fileName.endsWith(".tsx")) {
+        if (fileName.endsWith(".tsx"))
             return typescript_1.default.ScriptKind.TSX;
-        }
-        if (fileName.endsWith(".ts")) {
+        if (fileName.endsWith(".ts"))
             return typescript_1.default.ScriptKind.TS;
-        }
-        if (fileName.endsWith(".jsx")) {
+        if (fileName.endsWith(".jsx"))
             return typescript_1.default.ScriptKind.JSX;
-        }
-        if (fileName.endsWith(".js")) {
+        if (fileName.endsWith(".js"))
             return typescript_1.default.ScriptKind.JS;
-        }
-        if (fileName.endsWith(".json")) {
+        if (fileName.endsWith(".json"))
             return typescript_1.default.ScriptKind.JSON;
-        }
         return typescript_1.default.ScriptKind.Unknown;
     }
-    rebuild() {
-        this.builder = typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram([...this.rootNames], this.compilerOptions, this.host, this.builder);
+    rebuildProgram() {
+        this.program = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+    }
+    /** Register file content without rebuilding the TS program (batch via {@link flushUpdates}). */
+    stageFile(fileName, content) {
+        const normalized = this.normalize(fileName);
+        this.registry.update(normalized, content);
+        this.rootNames.add(normalized);
+    }
+    flushUpdates() {
+        this.rebuildProgram();
     }
     async updateFile(fileName, content) {
         const normalized = this.normalize(fileName);
         const processed = await (0, processFile_1.processFile)(normalized, content);
-        this.registry.update(processed.fileName, processed.content);
-        this.rootNames.add(processed.fileName);
-        this.rebuild();
+        this.stageFile(processed.fileName, processed.content);
+        this.rebuildProgram();
     }
     removeFile(fileName) {
         const normalized = this.normalize(fileName);
         this.registry.remove(normalized);
         this.rootNames.delete(normalized);
-        this.rebuild();
-    }
-    invalidate() {
-        this.registry.invalidate();
-        this.rebuild();
+        this.rebuildProgram();
     }
     getProgram() {
-        return this.builder.getProgram();
+        return this.program;
     }
     getChecker() {
-        return this.builder.getProgram().getTypeChecker();
+        return this.program.getTypeChecker();
     }
     getSourceFile(fileName) {
-        return this.builder.getProgram().getSourceFile(this.normalize(fileName));
+        return this.program.getSourceFile(this.normalize(fileName));
     }
     getSemanticDiagnostics(fileName) {
-        const program = this.builder.getProgram();
         if (!fileName) {
-            return typescript_1.default.getPreEmitDiagnostics(program);
+            return typescript_1.default.getPreEmitDiagnostics(this.program);
         }
         const sourceFile = this.getSourceFile(fileName);
         if (!sourceFile) {
             return [];
         }
         return [
-            ...program.getSemanticDiagnostics(sourceFile),
-            ...program.getSyntacticDiagnostics(sourceFile),
+            ...this.program.getSemanticDiagnostics(sourceFile),
+            ...this.program.getSyntacticDiagnostics(sourceFile),
         ];
     }
     resolveModule(moduleName, fromFile) {
@@ -162,20 +190,14 @@ class CompilerContext {
                 continue;
             }
             const resolved = this.resolveModule(specifier.text, source.fileName);
-            if (!resolved) {
-                continue;
+            if (resolved) {
+                modules.add(this.normalize(resolved));
             }
-            modules.add(this.normalize(resolved));
         }
-        return [
-            ...modules,
-        ];
+        return [...modules];
     }
     getAllSourceFiles() {
-        return this.builder.getProgram().getSourceFiles().filter(sf => !sf.isDeclarationFile);
-    }
-    getRealFileName(fileName) {
-        return fileName;
+        return this.program.getSourceFiles().filter((sf) => !sf.isDeclarationFile);
     }
 }
 exports.CompilerContext = CompilerContext;

package/dist/config/config.js

@@ -13,10 +13,21 @@ exports.CONFIG_NAME = "eventra.json";
 const DEFAULT_INCLUDE = ["**/*.{ts,tsx,js,jsx}"];
 const DEFAULT_EXCLUDE = ["node_modules", "dist", ".next", ".git"];
 function normalizeConfig(config) {
+    const functionWrappers = (config.functionWrappers ?? [])
+        .filter((w) => w?.name)
+        .map((w) => ({ name: w.name }));
+    const seen = new Set();
+    const uniqueWrappers = functionWrappers.filter((w) => {
+        if (seen.has(w.name))
+            return false;
+        seen.add(w.name);
+        return true;
+    });
     return {
         apiKey: config.apiKey ?? "",
         endpoint: config.endpoint ?? "",
-        events: config.events ?? [],
+        events: [...(config.events ?? [])].sort(),
+        functionWrappers: uniqueWrappers.sort((a, b) => a.name.localeCompare(b.name)),
         sync: {
             include: config.sync?.include ?? DEFAULT_INCLUDE,
             exclude: config.sync?.exclude ?? DEFAULT_EXCLUDE,
@@ -25,7 +36,7 @@ function normalizeConfig(config) {
 }
 async function loadConfig() {
     const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
-    if (!await fs_extra_1.default.pathExists(configPath)) {
+    if (!(await fs_extra_1.default.pathExists(configPath))) {
         return null;
     }
     try {

package/dist/core/EventraEngine.js

@@ -14,8 +14,9 @@ const resolvedCallCache_1 = require("../analysis/cache/resolvedCallCache");
 const resolvedExportCache_1 = require("../analysis/cache/resolvedExportCache");
 const returnPropagationCache_1 = require("../analysis/cache/returnPropagationCache");
 const symbolInvalidation_1 = require("../analysis/cache/symbolInvalidation");
+const analyzeFile_1 = require("../analysis/engine/analyzeFile");
 const wrapperRegistry_1 = require("../analysis/symbols/wrapperRegistry");
-const recursiveWrapperAnalyzer_1 = require("../analysis/engine/recursiveWrapperAnalyzer");
+const processFile_1 = require("../filesystem/processFile");
 const EMPTY_RESULT = () => ({
     events: new Set(),
     detectedFunctionWrappers: new Set(),
@@ -29,11 +30,13 @@ class EventraEngine {
     returnPropagationCache = new returnPropagationCache_1.ReturnPropagationCache();
     resolvedExportCache = new resolvedExportCache_1.ResolvedExportCache();
     wrapperRegistry;
+    fileIndices = new Map();
     fileResults = new Map();
     normalizedPathCache = new Map();
     isPreloading = false;
     lastConfig = {
         events: [],
+        functionWrappers: [],
         sync: {
             include: [],
             exclude: [],
@@ -43,7 +46,7 @@ class EventraEngine {
         this.compiler = new compilerContext_1.CompilerContext(rootDir);
         this.wrapperRegistry = new wrapperRegistry_1.WrapperRegistry(this.compiler.getChecker(), this.resolvedExportCache);
         this.scheduler = new scheduler_1.Scheduler(async (updates) => {
-            // APPLY UPDATES
+            const affected = new Set();
             for (const [file, content] of updates) {
                 const existing = this.compiler.getSourceFile(file);
                 if (existing) {
@@ -51,27 +54,17 @@ class EventraEngine {
                 }
                 await this.compiler.updateFile(file, content);
                 this.updateImportGraph(file);
-            }
-            // COLLECT AFFECTED FILES
-            const affected = new Set();
-            for (const file of updates.keys()) {
-                const dependents = this.importGraph.collectDependents(file);
-                for (const dependent of dependents) {
+                affected.add(file);
+                for (const dependent of this.importGraph.collectDependents(file)) {
                     affected.add(dependent);
                 }
             }
-            // RE-ANALYZE
-            for (const file of affected) {
-                await this.analyzeFile(file, this.lastConfig);
-            }
+            await this.reanalyzeFiles([...affected], this.lastConfig);
         });
     }
     beginPreload() {
         this.isPreloading = true;
     }
-    endPreload() {
-        this.isPreloading = false;
-    }
     normalize(fileName) {
         const cached = this.normalizedPathCache.get(fileName);
         if (cached) {
@@ -113,45 +106,92 @@ class EventraEngine {
             throw new Error("preload phase not active");
         }
         const normalized = this.normalize(fileName);
-        await this.compiler.updateFile(normalized, content);
-        this.updateImportGraph(normalized);
+        const processed = await (0, processFile_1.processFile)(normalized, content);
+        this.compiler.stageFile(processed.fileName, processed.content);
+    }
+    endPreload() {
+        this.isPreloading = false;
+        this.compiler.flushUpdates();
+        for (const sourceFile of this.compiler.getAllSourceFiles()) {
+            this.updateImportGraph(sourceFile.fileName);
+        }
     }
     async updateFile(fileName, content, config) {
         this.lastConfig = config;
         const normalized = this.normalize(fileName);
         await this.scheduler.enqueue(normalized, content);
     }
+    refreshChecker() {
+        this.wrapperRegistry.setChecker(this.compiler.getChecker());
+    }
+    async runFullAnalysis(fileNames, config) {
+        this.lastConfig = config;
+        this.refreshChecker();
+        const normalized = fileNames.map((f) => this.normalize(f));
+        for (const file of normalized) {
+            this.indexFile(file, config);
+        }
+        for (const file of normalized) {
+            this.extractFile(file, config);
+        }
+    }
+    async reanalyzeFiles(fileNames, config) {
+        this.lastConfig = config;
+        this.refreshChecker();
+        const normalized = fileNames.map((f) => this.normalize(f));
+        for (const file of normalized) {
+            this.indexFile(file, config);
+        }
+        for (const file of normalized) {
+            this.extractFile(file, config);
+        }
+    }
+    indexFile(fileName, _config) {
+        const normalized = this.normalize(fileName);
+        const source = this.compiler.getSourceFile(normalized);
+        if (!source) {
+            this.fileIndices.delete(normalized);
+            return;
+        }
+        const index = (0, analyzeFile_1.indexSourceFile)(source, this.compiler.getChecker(), this.wrapperRegistry);
+        this.fileIndices.set(normalized, index);
+    }
+    extractFile(fileName, config) {
+        const normalized = this.normalize(fileName);
+        const index = this.fileIndices.get(normalized);
+        if (!index) {
+            this.fileResults.delete(normalized);
+            return EMPTY_RESULT();
+        }
+        const result = (0, analyzeFile_1.extractFromIndex)(index, config, this.compiler.getChecker(), this.wrapperRegistry, this.evaluationCache, this.resolvedCallCache, this.returnPropagationCache, this.resolvedExportCache);
+        this.fileResults.set(normalized, result);
+        return result;
+    }
     async scanFile(fileName, config) {
         this.lastConfig = config;
-        return await this.analyzeFile(fileName, config);
+        this.refreshChecker();
+        this.indexFile(fileName, config);
+        return this.extractFile(fileName, config);
     }
     async removeFile(fileName, config) {
         const normalized = this.normalize(fileName);
+        const existing = this.compiler.getSourceFile(normalized);
+        if (existing) {
+            (0, symbolInvalidation_1.invalidateSourceFileSymbols)(existing, this.compiler.getChecker(), this.evaluationCache, this.resolvedCallCache, this.resolvedExportCache, this.returnPropagationCache, this.wrapperRegistry);
+        }
         const affected = this.importGraph.collectDependents(normalized);
         this.importGraph.removeFile(normalized);
         this.compiler.removeFile(normalized);
+        this.fileIndices.delete(normalized);
         this.fileResults.delete(normalized);
         this.normalizedPathCache.delete(fileName);
         this.normalizedPathCache.delete(normalized);
         const nextConfig = config ?? this.lastConfig;
-        for (const file of affected) {
-            if (file === normalized) {
-                continue;
-            }
-            await this.analyzeFile(file, nextConfig);
+        const toReanalyze = [...affected].filter((f) => f !== normalized);
+        if (toReanalyze.length > 0) {
+            await this.reanalyzeFiles(toReanalyze, nextConfig);
         }
     }
-    async analyzeFile(fileName, config) {
-        const normalized = this.normalize(fileName);
-        const source = this.compiler.getSourceFile(normalized);
-        if (!source) {
-            this.fileResults.delete(normalized);
-            return EMPTY_RESULT();
-        }
-        const result = await (0, recursiveWrapperAnalyzer_1.analyzeFileRecursive)(source, config, this.wrapperRegistry, this.evaluationCache, this.resolvedCallCache, this.returnPropagationCache, this.resolvedExportCache);
-        this.fileResults.set(normalized, result);
-        return result;
-    }
     getAllEvents() {
         const events = new Set();
         for (const result of this.fileResults.values()) {
@@ -159,9 +199,21 @@ class EventraEngine {
                 events.add(event);
             }
         }
-        return [
-            ...events,
-        ].sort();
+        return [...events].sort();
+    }
+    getAllFunctionWrappers() {
+        const wrappers = new Set();
+        for (const result of this.fileResults.values()) {
+            for (const name of result.detectedFunctionWrappers) {
+                if (name && name !== "anonymous" && !name.startsWith("__")) {
+                    wrappers.add(name);
+                }
+            }
+        }
+        return [...wrappers].sort();
+    }
+    getScanResult(fileName) {
+        return this.fileResults.get(this.normalize(fileName)) ?? EMPTY_RESULT();
     }
 }
 exports.EventraEngine = EventraEngine;

package/dist/core/projectScanner.js

@@ -12,9 +12,8 @@ const processFile_1 = require("../filesystem/processFile");
 const getVirtualFile_1 = require("../filesystem/getVirtualFile");
 async function getParsedFile(file, cache) {
     const existing = cache.get(file);
-    if (existing) {
+    if (existing)
         return existing;
-    }
     const raw = await promises_1.default.readFile(file, "utf8");
     const parsed = await (0, processFile_1.processFile)(file, raw);
     cache.set(file, parsed);
@@ -28,13 +27,11 @@ async function scanProject(config) {
     const engine = new EventraEngine_1.EventraEngine(process.cwd());
     const cache = new Map();
     const toScan = new Set();
-    // COLLECT
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf8");
-            if (raw.length > 2_000_000) {
+            if (raw.length > 2_000_000)
                 continue;
-            }
             const parsed = await (0, processFile_1.processFile)(file, raw);
             cache.set(file, parsed);
             toScan.add(file);
@@ -42,29 +39,26 @@ async function scanProject(config) {
                 toScan.add(path_1.default.resolve(path_1.default.dirname(file), dep));
             }
         }
-        catch {
+        catch (err) {
+            console.error(`skip: ${file}`, err instanceof Error ? err.message : err);
         }
     }
-    // PRELOAD
+    const virtualFiles = [...toScan].map((f) => (0, getVirtualFile_1.getVirtualFile)(f));
     engine.beginPreload();
     for (const file of toScan) {
         try {
             const parsed = await getParsedFile(file, cache);
             await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content);
         }
-        catch {
+        catch (err) {
+            console.error(`preload skip: ${file}`, err instanceof Error ? err.message : err);
         }
     }
     engine.endPreload();
-    // SCAN
+    await engine.runFullAnalysis(virtualFiles, config);
     const results = new Map();
     for (const file of toScan) {
-        try {
-            const result = await engine.scanFile((0, getVirtualFile_1.getVirtualFile)(file), config);
-            results.set(file, result);
-        }
-        catch {
-        }
+        results.set(file, engine.getScanResult((0, getVirtualFile_1.getVirtualFile)(file)));
     }
     return {
         engine,

package/dist/core/scanResults.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfigFromScan = buildConfigFromScan;
+exports.persistScanResults = persistScanResults;
+const config_1 = require("../config/config");
+function buildConfigFromScan(config, engine) {
+    const functionWrappers = engine
+        .getAllFunctionWrappers()
+        .map((name) => ({ name }));
+    return {
+        ...config,
+        events: engine.getAllEvents(),
+        functionWrappers,
+    };
+}
+async function persistScanResults(config, engine) {
+    await (0, config_1.saveConfig)(buildConfigFromScan(config, engine));
+}

package/dist/index.js

@@ -33,13 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
+const package_json_1 = __importDefault(require("../package.json"));
 const program = new commander_1.Command();
 program
     .name("eventra")
     .description("Eventra CLI")
-    .version("0.0.1");
+    .version(package_json_1.default.version);
 program
     .command("init")
     .action(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.3.5",
+  "version": "0.3.9",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "type": "commonjs",
@@ -25,7 +25,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/index.ts",
-    "test": "tsx tests/run.ts",
+    "test": "pnpm run clean && pnpm run build && tsx tests/run.ts",
     "clean": "rm -rf dist"
   },
   "dependencies": {

package/dist/analysis/engine/recursiveWrapperAnalyzer.js

@@ -1,76 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeFileRecursive = analyzeFileRecursive;
-const typescript_1 = __importDefault(require("typescript"));
-const propagationAnalyzer_1 = require("../scanner/analyzer/propagationAnalyzer");
-const extractor_1 = require("../extractor/extractor");
-async function analyzeFileRecursive(sourceFile, config, wrapperRegistry, evaluationCache, resolvedCallCache, returnPropagationCache, resolvedExportCache) {
-    const checker = wrapperRegistry["checker"];
-    const sinks = [];
-    const wrappers = [];
-    const trackCalls = [];
-    // Support empty functionWrappers
-    const wrapperNames = new Set(config.functionWrappers?.map(w => w.name) ?? []);
-    function visit(node, parentFunction) {
-        // Detect calls to configured wrapper functions
-        if (typescript_1.default.isCallExpression(node)) {
-            const callName = getCallName(node.expression);
-            if (wrapperNames.has(callName)) {
-                // Track this wrapper call
-                sinks.push({ call: node, trackedArguments: [{ index: 0, propertyPath: [] }] });
-                trackCalls.push({
-                    node,
-                    sourceFile,
-                    trackedArguments: node.arguments.filter(typescript_1.default.isExpression)
-                });
-            }
-        }
-        // Detect and analyze function declarations / expressions / methods
-        if (typescript_1.default.isFunctionDeclaration(node) ||
-            typescript_1.default.isFunctionExpression(node) ||
-            typescript_1.default.isArrowFunction(node) ||
-            typescript_1.default.isMethodDeclaration(node)) {
-            const localSinks = sinks.filter(s => isNodeInside(s.call, node));
-            const wrapper = (0, propagationAnalyzer_1.analyzeWrapperPropagation)(node, checker, localSinks);
-            if (wrapper) {
-                wrappers.push(wrapper);
-                wrapperRegistry.set(wrapper);
-            }
-            // Recurse into function body
-            if (node.body) {
-                typescript_1.default.forEachChild(node.body, child => visit(child, node));
-            }
-            return;
-        }
-        // Recurse into child nodes
-        typescript_1.default.forEachChild(node, child => visit(child, parentFunction));
-    }
-    visit(sourceFile);
-    // Extract events from tracked calls and wrapper metadata
-    return (0, extractor_1.extractEvents)({
-        fileName: sourceFile.fileName,
-        sourceFile,
-        sinks,
-        trackCalls,
-        wrappers,
-    }, checker, config, evaluationCache, resolvedExportCache, resolvedCallCache, returnPropagationCache, wrapperRegistry);
-}
-function isNodeInside(child, fn) {
-    let current = child;
-    while (current) {
-        if (current === fn)
-            return true;
-        current = current.parent;
-    }
-    return false;
-}
-function getCallName(expr) {
-    if (typescript_1.default.isIdentifier(expr))
-        return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr) || typescript_1.default.isPropertyAccessChain(expr))
-        return expr.name.text;
-    return "";
-}