@eventra_dev/eventra-cli 0.1.25 → 0.1.27

package/README.md

@@ -9,23 +9,29 @@
 [![TypeScript](https://img.shields.io/badge/typescript-ready-blue.svg)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/npm/l/@eventra_dev/eventra-cli)]()
 
-Eventra CLI automatically discovers feature usage events in your codebase and syncs them with Eventra.
+Eventra CLI automatically discovers and tracks event usage across your codebase — even through abstractions like wrappers, variables, and cross-file calls.
 
 ---
 
-# Installation
+## Overview
 
-```bash
-npm install -D @eventra_dev/eventra-cli
-```
+Eventra scans your codebase using a TypeScript-powered engine and extracts event usage — even through abstractions like wrappers, variables, and cross-file calls.
+
+It requires no runtime instrumentation and fits naturally into CI/CD workflows.
+
+---
+
+## Installation
 
 ```bash
+npm install -D @eventra_dev/eventra-cli
+# or
 pnpm add -D @eventra_dev/eventra-cli
 ```
 
 ---
 
-# Quick Start
+## Quick Start
 
 ```bash
 eventra init
@@ -36,22 +42,43 @@ eventra send
 
 ---
 
-# Commands
+## How it works
 
-## eventra init
+1. Parses your project using the TypeScript AST
+2. Resolves function calls, imports, and dependencies
+3. Tracks event propagation through variables and wrappers
+4. Extracts event names and aggregates them
 
-Creates `eventra.json` configuration file.
+No runtime required. No SDK needed.
 
 ---
 
-## eventra sync
+## Why Eventra
+
+- Prevent missing or inconsistent event tracking
+- Keep your analytics schema in sync with code
+- Detect dead or unused events
+- Integrate validation into CI pipelines
+
+---
 
-Scans your project and discovers events automatically.
+## Commands
 
-### Supports:
+### `eventra init`
+Creates `eventra.json` configuration file.
+
+---
 
-- track("event")
-- analytics.track("event")
+### `eventra sync`
+Scans your project and updates the list of detected events.
+
+#### Supports
+
+- Direct calls
+```ts
+track("event")
+analytics.track("event")
+```
 
 - Variables
 ```ts
@@ -74,7 +101,7 @@ track(`click_${type}`)
 track(condition ? "a" : "b")
 ```
 
-- Object format
+- Object payloads
 ```ts
 track({ event: "click" })
 ```
@@ -88,36 +115,27 @@ const trackFeature = (name: string) => {
 trackFeature("click")
 ```
 
-- Multi-argument wrappers
-```ts
-trackFeature("test", "click")
-```
-
-- Cross-file tracking
-
-- Vue / Svelte / Astro support
+- Cross-file event resolution
+- Framework templates (Vue, Svelte, Astro)
 
 ---
 
-## eventra check
-
-Validate events without modifying config.
+### `eventra check`
+Validates detected events against config.
 
 ```bash
 eventra check
 ```
 
-### Detects:
-
+Detects:
 - New events
 - Removed events
-- Dynamic values
+- Inconsistent tracking usage
 
 ---
 
-## eventra check --fix
-
-Auto-fix mode.
+### `eventra check --fix`
+Automatically updates config to match detected events.
 
 ```bash
 eventra check --fix
@@ -125,9 +143,8 @@ eventra check --fix
 
 ---
 
-## eventra watch
-
-Real-time event detection.
+### `eventra watch`
+Runs in watch mode and updates events in real time.
 
 ```bash
 eventra watch
@@ -135,9 +152,8 @@ eventra watch
 
 ---
 
-## eventra send
-
-Send events to backend.
+### `eventra send`
+Sends events to Eventra backend.
 
 ```bash
 eventra send
@@ -145,11 +161,12 @@ eventra send
 
 ---
 
-# Configuration
+## Configuration
 
 ```json
 {
   "apiKey": "",
+  "endpoint": "",
   "events": [],
   "wrappers": [],
   "functionWrappers": [],
@@ -163,25 +180,20 @@ eventra send
 
 ---
 
-# Supported Frameworks
+## Supported Environments
+
+Eventra works with **any JavaScript or TypeScript codebase**.
 
-- React
-- Vue
-- Svelte
-- Astro
-- Node.js
-- Express
-- NestJS
-- Fastify
+No framework limitations.
 
 ---
 
-# Requirements
+## Requirements
 
 - Node.js 18+
 
 ---
 
-# License
+## License
 
 MIT

package/dist/commands/watch.js

@@ -13,6 +13,9 @@ const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
 const getVirtualFile_1 = require("../utils/getVirtualFile");
+function normalize(file) {
+    return path_1.default.resolve(file).replace(/\\/g, "/");
+}
 async function watch() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
@@ -29,28 +32,29 @@ async function watch() {
     // COLLECT + CACHE
     for (const file of files) {
         try {
-            const raw = await promises_1.default.readFile(file, "utf-8");
+            const abs = normalize(file);
+            const raw = await promises_1.default.readFile(abs, "utf-8");
             if (raw.length > 2_000_000)
-                continue; // safeguard
-            const parsed = (0, processFile_1.processFile)(file, raw);
-            cache.set(file, parsed);
-            toScan.add(file);
+                continue;
+            const parsed = (0, processFile_1.processFile)(abs, raw);
+            cache.set(abs, parsed);
+            toScan.add(abs);
             for (const dep of parsed.deps) {
-                const absDep = path_1.default.resolve(dep);
-                toScan.add(absDep);
+                toScan.add(normalize(dep));
             }
         }
         catch {
             console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
-    // PRELOAD (TS PROGRAM)
+    // PRELOAD
     for (const file of toScan) {
         try {
             let parsed = cache.get(file);
             if (!parsed) {
                 const raw = await promises_1.default.readFile(file, "utf-8");
                 parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
             }
             const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
             engine.preloadFile?.(virtual, parsed.content);
@@ -68,7 +72,7 @@ async function watch() {
             const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
             engine.scanFile(virtual, parsed.content, config);
             for (const dep of parsed.deps) {
-                watchedDeps.add(path_1.default.resolve(dep));
+                watchedDeps.add(normalize(dep));
             }
         }
         catch { }
@@ -94,19 +98,33 @@ async function watch() {
                 const parsed = (0, processFile_1.processFile)(item.real, raw);
                 cache.set(item.real, parsed);
                 engine.updateFile(item.virtual, parsed.content, config);
-                // DEPS
+                // DEPENDENCY DIFF
+                const nextDeps = new Set();
                 for (const dep of parsed.deps) {
-                    const absDep = path_1.default.resolve(dep);
-                    if (!watchedDeps.has(absDep)) {
-                        watcher.add(absDep);
-                        watchedDeps.add(absDep);
+                    nextDeps.add(normalize(dep));
+                }
+                // add new deps
+                for (const dep of nextDeps) {
+                    if (!watchedDeps.has(dep)) {
+                        watcher.add(dep);
+                        watchedDeps.add(dep);
                     }
+                }
+                // remove old deps
+                for (const dep of [...watchedDeps]) {
+                    if (!nextDeps.has(dep)) {
+                        watcher.unwatch(dep);
+                        watchedDeps.delete(dep);
+                    }
+                }
+                // preload deps
+                for (const dep of nextDeps) {
                     try {
-                        const depRaw = await promises_1.default.readFile(absDep, "utf-8");
-                        const depParsed = (0, processFile_1.processFile)(absDep, depRaw);
-                        cache.set(absDep, depParsed);
-                        const depVirtual = (0, getVirtualFile_1.getVirtualFile)(absDep);
-                        engine.updateFile(depVirtual, depParsed.content, config);
+                        const raw = await promises_1.default.readFile(dep, "utf-8");
+                        const parsedDep = (0, processFile_1.processFile)(dep, raw);
+                        cache.set(dep, parsedDep);
+                        const virtual = (0, getVirtualFile_1.getVirtualFile)(dep);
+                        engine.updateFile(virtual, parsedDep.content, config);
                     }
                     catch { }
                 }
@@ -130,13 +148,13 @@ async function watch() {
     };
     // SCHEDULER
     const schedule = (file) => {
-        const abs = path_1.default.resolve(file);
+        const abs = normalize(file);
         const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
         console.log(chalk_1.default.gray(`change: ${file}`));
         queued.set(abs, { real: abs, virtual });
         if (timer)
             clearTimeout(timer);
-        timer = setTimeout(run, 250);
+        timer = setTimeout(run, 200);
     };
     // WATCHER
     const watcher = chokidar_1.default.watch(config.sync.include, {
@@ -148,7 +166,7 @@ async function watch() {
         .on("add", schedule)
         .on("change", schedule)
         .on("unlink", async (file) => {
-        const abs = path_1.default.resolve(file);
+        const abs = normalize(file);
         console.log(chalk_1.default.gray(`remove: ${file}`));
         const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
         engine.removeFile(virtual, config);
@@ -162,7 +180,7 @@ async function watch() {
         .on("error", (err) => {
         console.error(chalk_1.default.red("Watcher error:"), err);
     });
-    // WATCH DEPS
+    // WATCH DEPS INIT
     for (const dep of watchedDeps) {
         watcher.add(dep);
     }

package/dist/engine/callResolver.js

@@ -23,15 +23,37 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
         const aliased = checker.getAliasedSymbol(symbol);
         return resolveFromSymbol(aliased, checker, visited, depth + 1);
     }
+    // re-export support
+    if (symbol.exports) {
+        for (const exp of symbol.exports.values()) {
+            const resolved = resolveFromSymbol(exp, checker, visited, depth + 1);
+            if (resolved)
+                return resolved;
+        }
+    }
     const decls = symbol.getDeclarations() ?? [];
     for (const decl of decls) {
+        // direct function
         if (isFunctionLike(decl)) {
             return decl;
         }
-        // MethodSignature
+        // VARIABLE → FUNCTION
+        if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+            if (isFunctionLike(decl.initializer)) {
+                return decl.initializer;
+            }
+            const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
+            if (innerSymbol && innerSymbol !== symbol) {
+                const resolved = resolveFromSymbol(innerSymbol, checker, visited, depth + 1);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        // MethodSignature (interface / type)
         if (typescript_1.default.isMethodSignature(decl)) {
             const parent = decl.parent;
-            if (typescript_1.default.isInterfaceDeclaration(parent) || typescript_1.default.isTypeLiteralNode(parent)) {
+            if (typescript_1.default.isInterfaceDeclaration(parent) ||
+                typescript_1.default.isTypeLiteralNode(parent)) {
                 const name = decl.name.getText();
                 const type = checker.getTypeAtLocation(parent);
                 const props = type.getProperties();
@@ -44,7 +66,7 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
                 }
             }
         }
-        // SAFE fallback
+        // fallback recursion
         const s = checker.getSymbolAtLocation(decl);
         if (s && s !== symbol) {
             const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
@@ -55,6 +77,28 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
     return null;
 }
 function resolveFunctionFromCall(expr, checker) {
+    // tracker.track
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        let symbol = checker.getSymbolAtLocation(expr.name);
+        if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (symbol) {
+            const resolved = resolveFromSymbol(symbol, checker);
+            if (resolved)
+                return resolved;
+        }
+    }
+    // tracker["track"]
+    if (typescript_1.default.isElementAccessExpression(expr)) {
+        const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
+        if (symbol) {
+            const resolved = resolveFromSymbol(symbol, checker);
+            if (resolved)
+                return resolved;
+        }
+    }
+    // normal call signatures
     const type = checker.getTypeAtLocation(expr);
     const signatures = type.getCallSignatures();
     for (const sig of signatures) {
@@ -64,7 +108,6 @@ function resolveFunctionFromCall(expr, checker) {
         if (isFunctionLike(decl)) {
             return decl;
         }
-        // interface method
         if (typescript_1.default.isMethodSignature(decl)) {
             const symbol = checker.getSymbolAtLocation(decl.name);
             if (symbol) {
@@ -74,5 +117,10 @@ function resolveFunctionFromCall(expr, checker) {
             }
         }
     }
+    // fallback
+    const symbol = checker.getSymbolAtLocation(expr);
+    if (symbol) {
+        return resolveFromSymbol(symbol, checker);
+    }
     return null;
 }

package/dist/engine/engine.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventraEngine = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const languageService_1 = require("./languageService");
 const scanner_1 = require("./scanner");
 const graph_1 = require("./graph");
@@ -16,31 +21,40 @@ class EventraEngine {
         const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
         this.graph = new graph_1.DependencyGraph(baseUrl, paths);
     }
+    normalize(file) {
+        return path_1.default.resolve(file).replace(/\\/g, "/");
+    }
+    empty() {
+        return {
+            events: new Set(),
+            detectedFunctionWrappers: new Set(),
+            detectedComponentWrappers: new Map(),
+        };
+    }
+    // PRELOAD
     preloadFile(file, content) {
+        file = this.normalize(file);
         this.ts.updateFile(file, content);
+        const source = this.ts.getSourceFile(file);
+        if (source) {
+            this.graph.update(file, source);
+        }
     }
     // SCAN FILE
     scanFile(file, content, config) {
+        file = this.normalize(file);
         const h = (0, hash_1.hash)(content);
-        // skip unchanged
         if (this.fileHash.get(file) === h) {
-            return (this.fileResults.get(file) ?? {
-                events: new Set(),
-                detectedFunctionWrappers: new Set(),
-                detectedComponentWrappers: new Map(),
-            });
+            return this.fileResults.get(file) ?? this.empty();
         }
         this.fileHash.set(file, h);
         this.ts.updateFile(file, content);
         const source = this.ts.getSourceFile(file);
         const checker = this.ts.getChecker();
         if (!source || !checker) {
-            return {
-                events: new Set(),
-                detectedFunctionWrappers: new Set(),
-                detectedComponentWrappers: new Map(),
-            };
+            return this.empty();
         }
+        // обновляем graph
         this.graph.update(file, source);
         const res = (0, scanner_1.scanSource)(source, checker, config);
         this.fileResults.set(file, res);
@@ -48,26 +62,35 @@ class EventraEngine {
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
+        file = this.normalize(file);
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
-            if ((0, boundary_1.isExternalFile)(dep))
-                continue;
-            const depContent = this.ts.getFileContent(dep);
-            if (!depContent)
+            const abs = this.normalize(dep);
+            if ((0, boundary_1.isExternalFile)(abs))
                 continue;
+            let depContent = this.ts.getFileContent(abs);
+            if (!depContent) {
+                try {
+                    depContent = fs_1.default.readFileSync(abs, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+            }
             const h = (0, hash_1.hash)(depContent);
-            if (this.fileHash.get(dep) === h)
+            if (this.fileHash.get(abs) === h) {
                 continue;
-            this.fileHash.set(dep, h);
-            this.ts.updateFile(dep, depContent);
-            const source = this.ts.getSourceFile(dep);
+            }
+            this.fileHash.set(abs, h);
+            this.ts.updateFile(abs, depContent);
+            const source = this.ts.getSourceFile(abs);
             const checker = this.ts.getChecker();
             if (!source || !checker)
                 continue;
-            this.graph.update(dep, source);
+            this.graph.update(abs, source);
             const r = (0, scanner_1.scanSource)(source, checker, config);
-            this.fileResults.set(dep, r);
+            this.fileResults.set(abs, r);
         }
         return res;
     }
@@ -81,33 +104,42 @@ class EventraEngine {
     }
     // REMOVE FILE
     removeFile(file, config) {
+        file = this.normalize(file);
+        const dependents = this.graph.getAllDependentsDeep(file);
         this.ts.removeFile(file);
         this.fileResults.delete(file);
         this.fileHash.delete(file);
         this.graph.remove(file);
-        const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
-            if ((0, boundary_1.isExternalFile)(dep))
-                continue;
-            const content = this.ts.getFileContent(dep);
-            if (!content)
+            const abs = this.normalize(dep);
+            if ((0, boundary_1.isExternalFile)(abs))
                 continue;
+            let content = this.ts.getFileContent(abs);
+            if (!content) {
+                try {
+                    content = fs_1.default.readFileSync(abs, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+            }
             const h = (0, hash_1.hash)(content);
-            if (this.fileHash.get(dep) === h)
+            if (this.fileHash.get(abs) === h)
                 continue;
-            this.fileHash.set(dep, h);
-            this.ts.updateFile(dep, content);
-            const source = this.ts.getSourceFile(dep);
+            this.fileHash.set(abs, h);
+            this.ts.updateFile(abs, content);
+            const source = this.ts.getSourceFile(abs);
             const checker = this.ts.getChecker();
             if (!source || !checker)
                 continue;
+            this.graph.update(abs, source);
             const r = (0, scanner_1.scanSource)(source, checker, config ?? {
                 events: [],
                 wrappers: [],
                 functionWrappers: [],
                 sync: { include: [], exclude: [] },
             });
-            this.fileResults.set(dep, r);
+            this.fileResults.set(abs, r);
         }
     }
 }

package/dist/engine/exportResolver.js

@@ -5,21 +5,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveExportedSymbol = resolveExportedSymbol;
 const typescript_1 = __importDefault(require("typescript"));
+function isRealDeclaration(node) {
+    return (typescript_1.default.isFunctionDeclaration(node) ||
+        typescript_1.default.isVariableDeclaration(node) ||
+        typescript_1.default.isClassDeclaration(node));
+}
 function resolveExportedSymbol(symbol, checker, visited = new Set()) {
     if (visited.has(symbol))
         return null;
     visited.add(symbol);
+    // unwrap alias
     if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
         const aliased = checker.getAliasedSymbol(symbol);
         return resolveExportedSymbol(aliased, checker, visited);
     }
-    if (symbol.getDeclarations()?.length) {
+    // export symbol
+    const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
+    if (exportSymbol && exportSymbol !== symbol) {
+        return resolveExportedSymbol(exportSymbol, checker, visited);
+    }
+    const decls = symbol.getDeclarations() ?? [];
+    if (decls.some(isRealDeclaration)) {
         return symbol;
     }
-    const declarations = symbol.getDeclarations() ?? [];
-    for (const decl of declarations) {
+    // exports (re-export)
+    for (const decl of decls) {
         const source = decl.getSourceFile();
-        const moduleSymbol = checker.getSymbolAtLocation(source);
+        const moduleSymbol = source.symbol;
         if (!moduleSymbol)
             continue;
         const exports = checker.getExportsOfModule(moduleSymbol);