@eventra_dev/eventra-cli 0.0.4 → 0.0.5

package/README.md

@@ -4,69 +4,68 @@
 
 # Eventra CLI
 
-[![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)
+[![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/)
 
-Eventra CLI automatically discovers feature usage events in your
-codebase and syncs them with Eventra.
+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
--   Keep events in sync
--   Register features in Eventra
--   Maintain consistent event naming
+- 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
+- framework-agnostic
+- static analysis based
+- zero runtime overhead
+- production-safe
+- backend + frontend compatible
 
-------------------------------------------------------------------------
+---
 
 # Installation
 
 ### npm
 
-``` bash
+```bash
 npm install -D @eventra_dev/eventra-cli
 ```
 
 ### pnpm
 
-``` bash
+```bash
 pnpm add -D @eventra_dev/eventra-cli
 ```
 
 ### yarn
 
-``` bash
+```bash
 yarn add -D @eventra_dev/eventra-cli
 ```
 
 ### npx
 
-``` bash
+```bash
 npx eventra init
 ```
 
-------------------------------------------------------------------------
+---
 
 # Quick Start
 
-``` bash
+```bash
 eventra init
 eventra sync
 eventra send
 ```
 
-------------------------------------------------------------------------
+---
 
 # Commands
 
@@ -74,60 +73,140 @@ eventra send
 
 Creates `eventra.json` configuration file.
 
-``` bash
+```bash
 eventra init
 ```
 
-------------------------------------------------------------------------
+---
 
 ## eventra sync
 
 Scans your project and discovers events automatically.
 
-``` ts
+### track() detection
+
+```ts
 tracker.track("feature_created")
 ```
 
-``` tsx
+```ts
+track("user_signup")
+```
+
+---
+
+### Component wrappers
+
+```tsx
 <TrackedButton event="feature_created" />
 ```
 
-``` tsx
+```tsx
 <MyComponent event="user_signup" />
 ```
 
-------------------------------------------------------------------------
+---
+
+### Function wrappers
+
+```ts
+trackFeature("feature_created")
+```
+
+```ts
+analytics.trackFeature("user_signup")
+```
+
+---
 
 ## eventra send
 
 Send events to Eventra backend.
 
-``` bash
+```bash
 eventra send
 ```
 
-------------------------------------------------------------------------
+New events are queued for processing and will appear in dashboard shortly.
+
+Processing typically takes:
+
+~1-2 minutes
+
+This delay ensures reliable event ingestion and aggregation.
+
+---
+
+# Configuration
+
+Eventra CLI creates `eventra.json`
+
+Example:
+
+```json
+{
+  "apiKey": "",
+  "events": [],
+  "wrappers": [],
+  "functionWrappers": [],
+  "sync": {
+    "include": ["**/*.{ts,tsx,js,jsx}"],
+    "exclude": [
+      "node_modules",
+      "dist",
+      ".next",
+      ".git"
+    ]
+  }
+}
+```
+
+---
 
 # Supported Frameworks
 
--   React
--   Next.js
--   Vue
--   Nuxt
--   Svelte
--   Astro
--   Node.js
--   Express
--   NestJS
+Frontend:
+
+- React
+- Next.js
+- Vue
+- Nuxt
+- Svelte
+- Astro
+
+Backend:
+
+- Node.js
+- 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
+- Node.js 18+
+- JavaScript / TypeScript project
 
-------------------------------------------------------------------------
+---
 
 # License
 

package/dist/commands/init.js

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

package/dist/commands/send.js

@@ -7,15 +7,17 @@ exports.send = send;
 const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("../utils/config");
+const package_json_1 = __importDefault(require("../../package.json"));
 const EVENTRA_ENDPOINT = process.env.EVENTRA_ENDPOINT ?? "";
-const CLI_VERSION = "0.0.1";
+const CLI_VERSION = package_json_1.default.version;
 async function send() {
-    let config = await (0, config_1.loadConfig)();
+    const config = await (0, config_1.loadConfig)();
     if (!config) {
         console.log(chalk_1.default.red("eventra.json not found. Run 'eventra init'"));
         return;
     }
     let apiKey = config.apiKey;
+    // ask api key
     if (!apiKey) {
         const answers = await inquirer_1.default.prompt([
             {
@@ -29,11 +31,21 @@ async function send() {
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.green("API key saved"));
     }
-    if (!config.events.length) {
+    // no events
+    if (!config.events?.length) {
         console.log(chalk_1.default.yellow("No events found. Run 'eventra sync'"));
         return;
     }
-    console.log(chalk_1.default.blue("Sending events..."));
+    if (!apiKey) {
+        console.log(chalk_1.default.red("API key required"));
+        return;
+    }
+    if (!EVENTRA_ENDPOINT) {
+        console.log(chalk_1.default.red("EVENTRA_ENDPOINT not configured"));
+        return;
+    }
+    console.log("");
+    console.log(chalk_1.default.blue(`Sending ${config.events.length} events...`));
     try {
         const res = await fetch(EVENTRA_ENDPOINT, {
             method: "POST",
@@ -50,18 +62,40 @@ async function send() {
                 }
             })
         });
-        if (res.status >= 400) {
-            console.log(chalk_1.default.red(`Failed (${res.status})`));
+        if (!res.ok) {
+            console.log(chalk_1.default.red(`Request failed (${res.status})`));
+            try {
+                const text = await res.text();
+                console.log(chalk_1.default.gray(text));
+            }
+            catch { }
             return;
         }
         const data = await res.json();
         console.log(chalk_1.default.green("Events registered successfully"));
+        // created
         if (data.created?.length) {
             console.log(chalk_1.default.green("\nNew events:"));
             data.created.forEach((e) => console.log(chalk_1.default.green(`+ ${e}`)));
         }
+        // existing
+        if (data.existing?.length) {
+            console.log(chalk_1.default.gray("\nExisting events:"));
+            data.existing.forEach((e) => console.log(chalk_1.default.gray(`• ${e}`)));
+        }
+        // processing notice
+        if (data.created?.length) {
+            console.log("");
+            console.log(chalk_1.default.yellow("Events queued for processing (~2 min)"));
+            console.log(chalk_1.default.gray("They will appear in dashboard shortly"));
+        }
+        console.log("");
+        console.log(chalk_1.default.gray(`Sent ${config.events.length} events`));
     }
-    catch {
+    catch (err) {
         console.log(chalk_1.default.red("Network error"));
+        if (err instanceof Error) {
+            console.log(chalk_1.default.gray(err.message));
+        }
     }
 }

package/dist/commands/sync.js

@@ -4,213 +4,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sync = sync;
-const ts_morph_1 = require("ts-morph");
-const fast_glob_1 = __importDefault(require("fast-glob"));
 const chalk_1 = __importDefault(require("chalk"));
-const inquirer_1 = __importDefault(require("inquirer"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const ts_morph_1 = require("ts-morph");
+const promises_1 = __importDefault(require("fs/promises"));
 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 sync() {
-    let config = await (0, config_1.loadConfig)();
+    const config = await (0, config_1.loadConfig)();
     if (!config) {
-        console.log(chalk_1.default.red("Run 'eventra init' first"));
+        console.log(chalk_1.default.red("Run 'eventra init'"));
         return;
     }
-    const events = new Set();
-    const project = new ts_morph_1.Project();
     console.log(chalk_1.default.blue("Scanning project..."));
+    const project = new ts_morph_1.Project();
+    const events = new Set();
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude
     });
-    // track()
     for (const file of files) {
-        const sourceFile = project.addSourceFileAtPath(file);
-        const calls = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
-        for (const call of calls) {
-            const expression = call.getExpression();
-            if (expression.getKind() ===
-                ts_morph_1.SyntaxKind.PropertyAccessExpression) {
-                const prop = expression.asKind(ts_morph_1.SyntaxKind.PropertyAccessExpression);
-                if (!prop)
-                    continue;
-                if (prop.getName() !== "track")
-                    continue;
-                const args = call.getArguments();
-                const eventArg = args[0];
-                if (!eventArg)
-                    continue;
-                let event = null;
-                // "event"
-                if (eventArg.getKind() ===
-                    ts_morph_1.SyntaxKind.StringLiteral) {
-                    event =
-                        eventArg
-                            .asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral)
-                            .getLiteralText();
-                }
-                // `event`
-                if (eventArg.getKind() ===
-                    ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) {
-                    event =
-                        eventArg
-                            .asKindOrThrow(ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral)
-                            .getLiteralText();
-                }
-                if (event) {
-                    events.add(event);
-                }
-            }
-        }
-    }
-    console.log(chalk_1.default.green(`Found ${events.size} track events`));
-    // wrappers setup
-    if (!config.wrappers.length) {
-        const { useWrapper } = await inquirer_1.default.prompt([
-            {
-                type: "confirm",
-                name: "useWrapper",
-                message: "Use wrapper components?",
-                default: true
-            }
-        ]);
-        if (useWrapper) {
-            const wrappers = [];
-            let addMore = true;
-            while (addMore) {
-                const answers = await inquirer_1.default.prompt([
-                    {
-                        type: "input",
-                        name: "name",
-                        message: "Wrapper component name:"
-                    },
-                    {
-                        type: "input",
-                        name: "prop",
-                        message: "Event prop name:"
-                    }
-                ]);
-                wrappers.push({
-                    name: answers.name,
-                    prop: answers.prop
-                });
-                const more = await inquirer_1.default.prompt([
-                    {
-                        type: "confirm",
-                        name: "more",
-                        message: "Add another wrapper?",
-                        default: false
-                    }
-                ]);
-                addMore = more.more;
-            }
-            config.wrappers = wrappers;
-        }
+        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 });
+        (0, track_1.scanTrack)(source).forEach((e) => events.add(e));
+        (0, function_wrappers_1.scanFunctionWrappers)(source, config.functionWrappers ?? []).forEach((e) => events.add(e));
+        (0, component_wrappers_1.scanComponentWrappers)(source, config.wrappers ?? []).forEach((e) => events.add(e));
     }
-    // scan wrappers
-    if (config.wrappers.length) {
-        console.log(chalk_1.default.blue("Scanning wrappers..."));
-        for (const file of files) {
-            const sourceFile = project.addSourceFileAtPath(file);
-            const elements = [
-                ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxOpeningElement),
-                ...sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.JsxSelfClosingElement)
-            ];
-            for (const element of elements) {
-                const tagName = element
-                    .getTagNameNode()
-                    .getText()
-                    .toLowerCase();
-                for (const wrapper of config.wrappers) {
-                    if (tagName !==
-                        wrapper.name.toLowerCase())
-                        continue;
-                    const attrs = element.getAttributes();
-                    for (const attr of attrs) {
-                        if (attr.getKind() !==
-                            ts_morph_1.SyntaxKind.JsxAttribute)
-                            continue;
-                        const attrNode = attr.asKind(ts_morph_1.SyntaxKind.JsxAttribute);
-                        if (!attrNode)
-                            continue;
-                        const attrName = attrNode
-                            .getNameNode()
-                            .getText()
-                            .toLowerCase();
-                        if (attrName !==
-                            wrapper.prop.toLowerCase())
-                            continue;
-                        const initializer = attrNode.getInitializer();
-                        if (!initializer)
-                            continue;
-                        let value = null;
-                        // event="signup"
-                        if (initializer.getKind() ===
-                            ts_morph_1.SyntaxKind.StringLiteral) {
-                            value =
-                                initializer
-                                    .asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral)
-                                    .getLiteralText();
-                        }
-                        // event={"signup"}
-                        if (initializer.getKind() ===
-                            ts_morph_1.SyntaxKind.JsxExpression) {
-                            const expr = initializer
-                                .asKindOrThrow(ts_morph_1.SyntaxKind.JsxExpression)
-                                .getExpression();
-                            if (expr?.getKind() ===
-                                ts_morph_1.SyntaxKind.StringLiteral) {
-                                value =
-                                    expr
-                                        .asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral)
-                                        .getLiteralText();
-                            }
-                        }
-                        if (value) {
-                            events.add(value);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // results
     const list = [...events].sort();
-    console.log("");
-    console.log(chalk_1.default.green("Found events:"));
-    list.forEach((e) => console.log(chalk_1.default.gray(`- ${e}`)));
-    console.log("");
-    // diff
-    const previous = config.events ?? [];
-    const added = list.filter((e) => !previous.includes(e));
-    const removed = previous.filter((e) => !list.includes(e));
-    if (added.length || removed.length) {
-        console.log(chalk_1.default.blue("Changes:"));
-        if (added.length) {
-            console.log(chalk_1.default.green("New events:"));
-            added.forEach((e) => console.log(chalk_1.default.green(`+ ${e}`)));
-        }
-        if (removed.length) {
-            console.log(chalk_1.default.red("Removed events:"));
-            removed.forEach((e) => console.log(chalk_1.default.red(`- ${e}`)));
-        }
-        console.log("");
-    }
-    else {
-        console.log(chalk_1.default.gray("No changes detected"));
-    }
-    // confirm
-    const { confirm } = await inquirer_1.default.prompt([
-        {
-            type: "confirm",
-            name: "confirm",
-            message: "Sync these events?",
-            default: true
-        }
-    ]);
-    if (!confirm) {
-        console.log(chalk_1.default.yellow("Sync cancelled"));
-        return;
-    }
     config.events = list;
     await (0, config_1.saveConfig)(config);
-    console.log(chalk_1.default.green("eventra.json updated"));
+    console.log(chalk_1.default.green(`Found ${list.length} events`));
 }

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/config.js

@@ -15,8 +15,11 @@ function normalizeConfig(config) {
         apiKey: config.apiKey ?? "",
         events: config.events ?? [],
         wrappers: config.wrappers ?? [],
+        functionWrappers: config.functionWrappers ?? [],
         sync: config.sync ?? {
-            include: ["**/*.{ts,tsx,js,jsx}"],
+            include: [
+                "**/*.{ts,tsx,js,jsx}"
+            ],
             exclude: [
                 "node_modules",
                 "dist",

package/dist/utils/extract.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractEvent = extractEvent;
+const ts_morph_1 = require("ts-morph");
+function extractEvent(call, path) {
+    const parts = path.split(".");
+    let node = call.getArguments()[Number(parts[0])];
+    if (!node)
+        return null;
+    for (let i = 1; i < parts.length; i++) {
+        if (ts_morph_1.Node.isObjectLiteralExpression(node)) {
+            const obj = node;
+            const prop = obj.getProperty(parts[i]);
+            if (!prop)
+                return null;
+            if (ts_morph_1.Node.isPropertyAssignment(prop)) {
+                const initializer = prop.getInitializer();
+                if (!initializer)
+                    return null;
+                node = initializer;
+            }
+        }
+    }
+    if (node &&
+        ts_morph_1.Node.isStringLiteral(node)) {
+        return node.getLiteralText();
+    }
+    return null;
+}

package/dist/utils/parsers/astro.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAstro = parseAstro;
+function parseAstro(content) {
+    return content;
+}

package/dist/utils/parsers/router.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectParser = detectParser;
+function detectParser(file) {
+    if (file.endsWith(".vue"))
+        return "vue";
+    if (file.endsWith(".svelte"))
+        return "svelte";
+    if (file.endsWith(".astro"))
+        return "astro";
+    return "ts";
+}

package/dist/utils/parsers/svelte.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSvelte = parseSvelte;
+function parseSvelte(content) {
+    return content;
+}

package/dist/utils/parsers/vue.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVue = parseVue;
+function parseVue(content) {
+    const template = content.match(/<template[\s\S]*?>([\s\S]*?)<\/template>/);
+    const script = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
+    return ((template?.[1] ?? "") +
+        "\n" +
+        (script?.[1] ?? ""));
+}