@eventra_dev/eventra-cli 0.0.18 → 0.0.19

package/README.md

@@ -1,3 +1,4 @@
+
 <p align="center">
 <img src="./assets/eventra-icon-animated.svg" width="120">
 </p>
@@ -7,56 +8,22 @@
 [![npm version](https://img.shields.io/npm/v/@eventra_dev/eventra-cli.svg)](https://www.npmjs.com/package/@eventra_dev/eventra-cli)
 [![npm downloads](https://img.shields.io/npm/dm/@eventra_dev/eventra-cli.svg)](https://www.npmjs.com/package/@eventra_dev/eventra-cli)
 [![TypeScript](https://img.shields.io/badge/typescript-ready-blue.svg)](https://www.typescriptlang.org/)
-[![Tests](https://github.com/and-1991/eventra-cli/actions/workflows/release.yml/badge.svg)]()
 [![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 helps you:
-
-- Discover feature usage automatically
-- Detect wrapper components
-- Detect wrapper functions
-- Keep events in sync
-- Register features in Eventra
-- Maintain consistent event naming
-
-It is designed to be:
-
-- framework-agnostic
-- static analysis based
-- zero runtime overhead
-- production-safe
-- backend + frontend compatible
-
 ---
 
 # Installation
 
-### npm
-
 ```bash
 npm install -D @eventra_dev/eventra-cli
 ```
 
-### pnpm
-
 ```bash
 pnpm add -D @eventra_dev/eventra-cli
 ```
 
-### yarn
-
-```bash
-yarn add -D @eventra_dev/eventra-cli
-```
-
-### npx
-
-```bash
-npx eventra init
-```
-
 ---
 
 # Quick Start
@@ -76,180 +43,142 @@ eventra send
 
 Creates `eventra.json` configuration file.
 
-```bash
-eventra init
-```
-
 ---
 
 ## eventra sync
 
 Scans your project and discovers events automatically.
 
-### track() detection
-
-```ts
-tracker.track("feature_created")
-```
+Supports:
 
-```ts
-track("user_signup")
-```
+- track("event")
+- analytics.track("event")
+- function wrappers
+- component wrappers
+- aliases
 
 ---
 
-### Component wrappers
+## eventra check
 
-```tsx
-<TrackedButton event="feature_created" />
-```
+Validate events without modifying config.
 
-```tsx
-<MyComponent event="user_signup" />
+```bash
+eventra check
 ```
 
----
+### Detects:
 
-### Function wrappers
+- New events
+- Unresolved dynamic events
 
-```ts
-trackFeature("feature_created")
-```
+### Output example:
 
-```ts
-analytics.trackFeature("user_signup")
 ```
+New events:
++ user_click (src/Button.tsx:42)
 
----
-
-## eventra check
-
-Validate events in your codebase without modifying `eventra.json`.
-
-This command is designed for CI/CD pipelines and ensures:
-
--   No new events are introduced unintentionally
--   All dynamic events are resolved via aliases
--   Event naming stays consistent
-
-``` bash
-eventra check
+Dynamic:
+- eventName (src/App.tsx:10)
 ```
 
-------------------------------------------------------------------------
-
-### What it checks
+---
 
-#### 1. New events
+## eventra check --fix
 
-If your code contains events not listed in `eventra.json`:
+Interactive auto-fix mode.
 
-``` ts
-trackFeature("new_event")
+```bash
+eventra check --fix
 ```
 
-CLI output:
+### What it does:
 
-    New events detected:
-    + new_event
-    ❌ Event check failed
+- Adds new events to config
+- Resolves dynamic events via alias
+- Allows skipping dynamic values
 
-------------------------------------------------------------------------
+---
 
-#### 2. Unresolved dynamic events
+## eventra watch
 
-If your code contains dynamic values without alias:
+Real-time event detection.
 
-``` ts
-trackFeature(eventName)
+```bash
+eventra watch
 ```
 
-CLI output:
-
-    Unresolved dynamic events:
-    - eventName
-    ❌ Event check failed
+### Features:
 
-------------------------------------------------------------------------
+- Detects new events instantly
+- Debounced updates
+- No duplicates
+- Ignores temp files
 
-### CI usage
+---
 
-``` bash
-pnpm eventra check
-```
+## eventra send
 
-#### GitHub Actions example
+Send events to backend.
 
-``` yaml
-- run: pnpm eventra check
+```bash
+eventra send
 ```
 
-------------------------------------------------------------------------
+---
 
-### Skipping dynamic events
+# Configuration
 
-You can explicitly ignore dynamic variables using aliases:
+Example `eventra.json`:
 
-``` json
+```json
 {
-  "aliases": {
-    "eventName": "__skip__"
+  "apiKey": "",
+  "events": [],
+  "wrappers": [],
+  "functionWrappers": [],
+  "aliases": {},
+  "sync": {
+    "include": ["**/*.{ts,tsx,js,jsx,vue,svelte,astro}"],
+    "exclude": ["node_modules", "dist", ".next", ".git"]
   }
 }
 ```
 
-------------------------------------------------------------------------
+---
 
-### When to use
+# Key Concepts
 
-Use `eventra check` to:
+### Aliases
 
--   enforce event consistency\
--   prevent accidental event creation\
--   validate analytics in pull requests
+```ts
+const EVENT = "user_click";
+track(EVENT);
+```
 
----
+Auto-resolved → `user_click`
 
-## eventra send
+---
 
-Send events to Eventra backend.
+### Dynamic events
 
-```bash
-eventra send
+```ts
+track(eventName);
 ```
 
-New events are queued for processing and will appear in dashboard shortly.
-
-Processing typically takes:
+Must be:
 
-~1-2 minutes
-
-This delay ensures reliable event ingestion and aggregation.
+- aliased
+- or skipped (`__skip__`)
 
 ---
 
-# Configuration
-
-Eventra CLI creates `eventra.json`
+### File tracking
 
-Example:
+All events include:
 
-```json
-{
-  "apiKey": "",
-  "events": [],
-  "wrappers": [],
-  "functionWrappers": [],
-  "sync": {
-    "include": ["**/*.{ts,tsx,js,jsx}"],
-    "exclude": [
-      "node_modules",
-      "dist",
-      ".next",
-      ".git"
-    ]
-  }
-}
+```
+event_name (file:line)
 ```
 
 ---
@@ -259,9 +188,7 @@ Example:
 Frontend:
 
 - React
-- Next.js
 - Vue
-- Nuxt
 - Svelte
 - Astro
 
@@ -271,31 +198,12 @@ Backend:
 - Express
 - NestJS
 - Fastify
-- Hono
-- Bun
-- Deno
-
----
-
-# How It Works
-
-Eventra CLI:
-
-1. Scans your codebase
-2. Detects tracking calls
-3. Detects wrapper components
-4. Detects wrapper functions
-5. Syncs discovered events
-6. Registers events in Eventra
-
-No runtime SDK required.
 
 ---
 
 # Requirements
 
 - Node.js 18+
-- JavaScript / TypeScript project
 
 ---
 

package/dist/commands/check.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const ts_morph_1 = require("ts-morph");
 const promises_1 = __importDefault(require("fs/promises"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("../utils/config");
 const router_1 = require("../utils/parsers/router");
 const vue_1 = require("../utils/parsers/vue");
@@ -16,7 +17,7 @@ const astro_1 = require("../utils/parsers/astro");
 const track_1 = require("../utils/scanners/track");
 const function_wrappers_1 = require("../utils/scanners/function-wrappers");
 const component_wrappers_1 = require("../utils/scanners/component-wrappers");
-async function check() {
+async function check({ fix = false }) {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
         console.log(chalk_1.default.red("eventra.json not found"));
@@ -25,19 +26,17 @@ async function check() {
     console.log(chalk_1.default.blue("Checking events..."));
     const project = new ts_morph_1.Project();
     const knownEvents = new Set(config.events ?? []);
-    const aliases = config.aliases ?? {};
-    const foundEvents = new Set();
-    const newEvents = new Set();
-    const unresolvedDynamic = new Set();
+    const aliases = { ...(config.aliases ?? {}) };
+    const foundEvents = new Map();
+    const newEvents = new Map();
+    const unresolvedDynamic = new Map();
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude
     });
     for (const file of files) {
         try {
-            // skip huge files
             const stat = await promises_1.default.stat(file);
             if (stat.size > 2 * 1024 * 1024) {
-                console.log(chalk_1.default.gray(`Skipped large file: ${file}`));
                 continue;
             }
             const parser = (0, router_1.detectParser)(file);
@@ -48,69 +47,107 @@ async function check() {
                 content = (0, svelte_1.parseSvelte)(content);
             if (parser === "astro")
                 content = (0, astro_1.parseAstro)(content);
-            const virtualFile = parser === "ts" ? file : file + ".tsx";
-            const source = project.createSourceFile(virtualFile, content, { overwrite: true });
+            const source = project.createSourceFile(file, content, {
+                overwrite: true
+            });
             const found = [
-                ...(0, track_1.scanTrack)(source, config),
-                ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? []),
-                ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [])
+                ...(0, track_1.scanTrack)(source, config, aliases),
+                ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? [], aliases),
+                ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [], aliases)
             ];
             for (const event of found) {
                 const { value, dynamic } = event;
                 if (!value)
                     continue;
-                // alias skip
-                if (aliases[value] === "__skip__") {
+                // skip
+                if (aliases[value] === "__skip__")
                     continue;
-                }
                 // alias resolve
-                if (aliases[value]) {
-                    foundEvents.add(aliases[value]);
+                if (value in aliases) {
+                    foundEvents.set(aliases[value], {
+                        ...event,
+                        value: aliases[value]
+                    });
                     continue;
                 }
-                // dynamic without alias
                 if (dynamic) {
-                    unresolvedDynamic.add(value);
+                    unresolvedDynamic.set(value, event);
                     continue;
                 }
-                // static
-                foundEvents.add(value);
+                foundEvents.set(value, event);
             }
-            // clear memory
             project.removeSourceFile(source);
         }
         catch {
-            console.log(chalk_1.default.gray(`Skipped file (error): ${file}`));
+            console.log(chalk_1.default.gray(`Skipped: ${file}`));
+        }
+    }
+    // find new
+    for (const [key, event] of foundEvents) {
+        if (!knownEvents.has(key)) {
+            newEvents.set(key, event);
         }
     }
-    // find new events
-    for (const event of foundEvents) {
-        if (!knownEvents.has(event)) {
-            newEvents.add(event);
+    // FIX MODE
+    if (fix) {
+        console.log(chalk_1.default.yellow("\nFix mode\n"));
+        // add new events
+        for (const [name] of newEvents) {
+            config.events.push(name);
+            console.log(chalk_1.default.green(`+ ${name}`));
+        }
+        // resolve dynamic
+        for (const [value] of unresolvedDynamic) {
+            const { action } = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "action",
+                    message: `Dynamic: ${value}`,
+                    choices: [
+                        { name: "Alias", value: "alias" },
+                        { name: "Skip", value: "skip" }
+                    ]
+                }
+            ]);
+            if (action === "skip") {
+                aliases[value] = "__skip__";
+                continue;
+            }
+            const { name } = await inquirer_1.default.prompt([
+                {
+                    type: "input",
+                    name: "name",
+                    message: "Event name:"
+                }
+            ]);
+            const normalized = name.trim().toLowerCase();
+            if (!normalized)
+                continue;
+            aliases[value] = normalized;
+            config.events.push(normalized);
+            console.log(chalk_1.default.green(`${value} → ${normalized}`));
         }
+        config.aliases = Object.fromEntries(Object.entries(aliases).sort());
+        config.events = [...new Set(config.events)].sort();
+        await (0, config_1.saveConfig)(config);
+        console.log(chalk_1.default.green("\n✔ Fixed"));
+        return;
     }
+    // NORMAL MODE
     let hasError = false;
-    // dynamic
-    if (unresolvedDynamic.size > 0) {
+    if (unresolvedDynamic.size) {
         hasError = true;
-        console.log(chalk_1.default.red("\nUnresolved dynamic events:"));
-        [...unresolvedDynamic]
-            .sort()
-            .forEach((e) => console.log(chalk_1.default.red(`- ${e}`)));
+        console.log(chalk_1.default.red("\nDynamic events:"));
+        unresolvedDynamic.forEach((e) => console.log(chalk_1.default.red(`- ${e.value} (${e.file}:${e.line})`)));
     }
-    // new events
-    if (newEvents.size > 0) {
+    if (newEvents.size) {
         hasError = true;
-        console.log(chalk_1.default.red("\nNew events detected:"));
-        [...newEvents]
-            .sort()
-            .forEach((e) => console.log(chalk_1.default.red(`+ ${e}`)));
+        console.log(chalk_1.default.red("\nNew events:"));
+        newEvents.forEach((e) => console.log(chalk_1.default.red(`+ ${e.value} (${e.file}:${e.line})`)));
     }
     if (hasError) {
-        console.log("");
-        console.log(chalk_1.default.red("Event check failed"));
-        console.log(chalk_1.default.red(`dynamic: ${unresolvedDynamic.size}, new: ${newEvents.size}`));
+        console.log(chalk_1.default.red("\nEvent check failed"));
         process.exit(1);
     }
-    console.log(chalk_1.default.green("\nAll events are valid"));
+    console.log(chalk_1.default.green("\nAll good"));
 }