@eventra_dev/eventra-cli 0.0.17 → 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
@@ -64,6 +31,7 @@ npx eventra init
 ```bash
 eventra init
 eventra sync
+eventra check
 eventra send
 ```
 
@@ -75,75 +43,93 @@ eventra send
 
 Creates `eventra.json` configuration file.
 
-```bash
-eventra init
-```
-
 ---
 
 ## eventra sync
 
 Scans your project and discovers events automatically.
 
-### track() detection
+Supports:
 
-```ts
-tracker.track("feature_created")
-```
+- track("event")
+- analytics.track("event")
+- function wrappers
+- component wrappers
+- aliases
 
-```ts
-track("user_signup")
+---
+
+## eventra check
+
+Validate events without modifying config.
+
+```bash
+eventra check
 ```
 
----
+### Detects:
 
-### Component wrappers
+- New events
+- Unresolved dynamic events
+
+### Output example:
 
-```tsx
-<TrackedButton event="feature_created" />
 ```
+New events:
++ user_click (src/Button.tsx:42)
 
-```tsx
-<MyComponent event="user_signup" />
+Dynamic:
+- eventName (src/App.tsx:10)
 ```
 
 ---
 
-### Function wrappers
+## eventra check --fix
 
-```ts
-trackFeature("feature_created")
-```
+Interactive auto-fix mode.
 
-```ts
-analytics.trackFeature("user_signup")
+```bash
+eventra check --fix
 ```
 
+### What it does:
+
+- Adds new events to config
+- Resolves dynamic events via alias
+- Allows skipping dynamic values
+
 ---
 
-## eventra send
+## eventra watch
 
-Send events to Eventra backend.
+Real-time event detection.
 
 ```bash
-eventra send
+eventra watch
 ```
 
-New events are queued for processing and will appear in dashboard shortly.
+### Features:
 
-Processing typically takes:
+- Detects new events instantly
+- Debounced updates
+- No duplicates
+- Ignores temp files
 
-~1-2 minutes
+---
+
+## eventra send
 
-This delay ensures reliable event ingestion and aggregation.
+Send events to backend.
+
+```bash
+eventra send
+```
 
 ---
 
 # Configuration
 
-Eventra CLI creates `eventra.json`
-
-Example:
+Example `eventra.json`:
 
 ```json
 {
@@ -151,28 +137,58 @@ Example:
   "events": [],
   "wrappers": [],
   "functionWrappers": [],
+  "aliases": {},
   "sync": {
-    "include": ["**/*.{ts,tsx,js,jsx}"],
-    "exclude": [
-      "node_modules",
-      "dist",
-      ".next",
-      ".git"
-    ]
+    "include": ["**/*.{ts,tsx,js,jsx,vue,svelte,astro}"],
+    "exclude": ["node_modules", "dist", ".next", ".git"]
   }
 }
 ```
 
 ---
 
+# Key Concepts
+
+### Aliases
+
+```ts
+const EVENT = "user_click";
+track(EVENT);
+```
+
+Auto-resolved → `user_click`
+
+---
+
+### Dynamic events
+
+```ts
+track(eventName);
+```
+
+Must be:
+
+- aliased
+- or skipped (`__skip__`)
+
+---
+
+### File tracking
+
+All events include:
+
+```
+event_name (file:line)
+```
+
+---
+
 # Supported Frameworks
 
 Frontend:
 
 - React
-- Next.js
 - Vue
-- Nuxt
 - Svelte
 - Astro
 
@@ -182,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

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+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");
+const svelte_1 = require("../utils/parsers/svelte");
+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({ 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..."));
+    const project = new ts_morph_1.Project();
+    const knownEvents = new Set(config.events ?? []);
+    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 {
+            const stat = await promises_1.default.stat(file);
+            if (stat.size > 2 * 1024 * 1024) {
+                continue;
+            }
+            const parser = (0, router_1.detectParser)(file);
+            let content = await promises_1.default.readFile(file, "utf-8");
+            if (parser === "vue")
+                content = (0, vue_1.parseVue)(content);
+            if (parser === "svelte")
+                content = (0, svelte_1.parseSvelte)(content);
+            if (parser === "astro")
+                content = (0, astro_1.parseAstro)(content);
+            const source = project.createSourceFile(file, content, {
+                overwrite: true
+            });
+            const found = [
+                ...(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;
+                // skip
+                if (aliases[value] === "__skip__")
+                    continue;
+                // alias resolve
+                if (value in aliases) {
+                    foundEvents.set(aliases[value], {
+                        ...event,
+                        value: aliases[value]
+                    });
+                    continue;
+                }
+                if (dynamic) {
+                    unresolvedDynamic.set(value, event);
+                    continue;
+                }
+                foundEvents.set(value, event);
+            }
+            project.removeSourceFile(source);
+        }
+        catch {
+            console.log(chalk_1.default.gray(`Skipped: ${file}`));
+        }
+    }
+    // find new
+    for (const [key, event] of foundEvents) {
+        if (!knownEvents.has(key)) {
+            newEvents.set(key, 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;
+    if (unresolvedDynamic.size) {
+        hasError = true;
+        console.log(chalk_1.default.red("\nDynamic events:"));
+        unresolvedDynamic.forEach((e) => console.log(chalk_1.default.red(`- ${e.value} (${e.file}:${e.line})`)));
+    }
+    if (newEvents.size) {
+        hasError = true;
+        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(chalk_1.default.red("\nEvent check failed"));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green("\nAll good"));
+}

package/dist/commands/sync.js

@@ -10,6 +10,8 @@ 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 detect_wrappers_1 = require("../utils/detect-wrappers");
+const detect_aliases_1 = require("../utils/detect-aliases");
 const router_1 = require("../utils/parsers/router");
 const vue_1 = require("../utils/parsers/vue");
 const svelte_1 = require("../utils/parsers/svelte");
@@ -32,65 +34,103 @@ async function sync() {
         ignore: config.sync.exclude
     });
     for (const file of files) {
-        const parser = (0, router_1.detectParser)(file);
-        let content = await promises_1.default.readFile(file, "utf-8");
-        if (parser === "vue")
-            content = (0, vue_1.parseVue)(content);
-        if (parser === "svelte")
-            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 found = [
-            ...(0, track_1.scanTrack)(source, config),
-            ...(0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? []),
-            ...(0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? [])
-        ];
-        for (const event of found) {
-            const { value, dynamic } = event;
-            if (!value)
-                continue;
-            // alias
-            if (aliases[value]) {
-                console.log(chalk_1.default.gray(`alias: ${value} → ${aliases[value]}`));
-                events.add(aliases[value]);
-                continue;
+        try {
+            const parser = (0, router_1.detectParser)(file);
+            let content = await promises_1.default.readFile(file, "utf-8");
+            if (parser === "vue")
+                content = (0, vue_1.parseVue)(content);
+            if (parser === "svelte")
+                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 });
+            // AUTO ALIASES
+            const detectedAliases = (0, detect_aliases_1.detectAliases)(source);
+            for (const key in detectedAliases) {
+                if (!(key in aliases)) {
+                    aliases[key] = detectedAliases[key];
+                    console.log(chalk_1.default.green(`Detected alias: ${key} → ${detectedAliases[key]}`));
+                }
             }
-            // static
-            if (!dynamic) {
-                events.add(value);
-                continue;
+            // AUTO WRAPPERS
+            const detected = (0, detect_wrappers_1.detectWrappers)(source);
+            // function wrappers
+            for (const fn of detected.functions) {
+                if (!config.functionWrappers?.some((w) => w.name === fn.name)) {
+                    config.functionWrappers.push(fn);
+                    console.log(chalk_1.default.green(`Detected function wrapper: ${fn.name}`));
+                }
             }
-            // already asked
-            if (asked.has(value)) {
-                continue;
+            // component wrappers
+            for (const comp of detected.components) {
+                if (!config.wrappers?.some((w) => w.name === comp.name)) {
+                    config.wrappers.push(comp);
+                    console.log(chalk_1.default.green(`Detected component wrapper: ${comp.name} (prop: ${comp.prop})`));
+                }
             }
-            // ask user
-            console.log(chalk_1.default.yellow("\nDynamic event detected:"));
-            console.log(chalk_1.default.gray(value));
-            const { name } = await inquirer_1.default.prompt([
-                {
-                    type: "input",
-                    name: "name",
-                    message: "Enter event name (or type 'skip'):"
+            // SCAN EVENTS
+            const found = [
+                ...(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;
+                // skip explicit ignore
+                if (value in aliases && aliases[value] === "__skip__") {
+                    continue;
+                }
+                // resolve alias
+                if (value in aliases) {
+                    events.add(aliases[value]);
+                    continue;
                 }
-            ]);
-            const normalized = name?.trim();
-            asked.add(value);
-            if (!normalized || normalized === "skip") {
-                continue;
+                // static
+                if (!dynamic) {
+                    events.add(value);
+                    continue;
+                }
+                // already handled
+                if (asked.has(value))
+                    continue;
+                // ASK ONLY IF NEEDED
+                console.log(chalk_1.default.yellow("\nDynamic event detected:"));
+                console.log(chalk_1.default.gray(value));
+                const { name } = await inquirer_1.default.prompt([
+                    {
+                        type: "input",
+                        name: "name",
+                        message: "Enter event name (or type 'skip'):"
+                    }
+                ]);
+                const normalized = name?.trim();
+                asked.add(value);
+                if (!normalized || normalized === "skip") {
+                    continue;
+                }
+                // save alias
+                aliases[value] = normalized;
+                console.log(chalk_1.default.green(`Saved alias: ${value} → ${normalized}`));
+                events.add(normalized);
             }
-            // save alias
-            aliases[value] = normalized;
-            events.add(normalized);
+            // free memory
+            project.removeSourceFile(source);
+        }
+        catch {
+            console.log(chalk_1.default.gray(`Skipped file: ${file}`));
         }
     }
-    config.aliases = aliases;
-    const list = [...events].sort();
-    config.events = list;
+    // SAVE CONFIG
+    config.aliases = Object.fromEntries(Object.entries(aliases).sort());
+    // MERGE
+    const merged = new Set([
+        ...config.events,
+        ...events
+    ]);
+    config.events = [...merged].sort();
     await (0, config_1.saveConfig)(config);
-    console.log(chalk_1.default.green(`Found ${list.length} events`));
+    console.log(chalk_1.default.green(`\nFound ${config.events.length} events`));
 }