@eventra_dev/eventra-cli 0.0.17 → 0.0.19

package/src/commands/check.ts

@@ -0,0 +1,197 @@
+import chalk from "chalk";
+import fg from "fast-glob";
+import { Project } from "ts-morph";
+import fs from "fs/promises";
+import inquirer from "inquirer";
+
+import { loadConfig, saveConfig } from "../utils/config";
+
+import { detectParser } from "../utils/parsers/router";
+import { parseVue } from "../utils/parsers/vue";
+import { parseSvelte } from "../utils/parsers/svelte";
+import { parseAstro } from "../utils/parsers/astro";
+
+import { scanTrack } from "../utils/scanners/track";
+import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
+import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
+
+import { ExtractedEvent } from "../types";
+
+export async function check({ fix = false }: { fix?: boolean }) {
+  const config = await loadConfig();
+
+  if (!config) {
+    console.log(chalk.red("eventra.json not found"));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue("Checking events..."));
+
+  const project = new Project();
+
+  const knownEvents = new Set(config.events ?? []);
+  const aliases = { ...(config.aliases ?? {}) };
+
+  const foundEvents = new Map<string, ExtractedEvent>();
+  const newEvents = new Map<string, ExtractedEvent>();
+  const unresolvedDynamic = new Map<string, ExtractedEvent>();
+
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude
+  });
+
+  for (const file of files) {
+    try {
+      const stat = await fs.stat(file);
+
+      if (stat.size > 2 * 1024 * 1024) {
+        continue;
+      }
+
+      const parser = detectParser(file);
+      let content = await fs.readFile(file, "utf-8");
+
+      if (parser === "vue") content = parseVue(content);
+      if (parser === "svelte") content = parseSvelte(content);
+      if (parser === "astro") content = parseAstro(content);
+
+      const source = project.createSourceFile(file, content, {
+        overwrite: true
+      });
+
+      const found: ExtractedEvent[] = [
+        ...scanTrack(source, config, aliases),
+        ...scanFunctionWrappers(source, config.functionWrappers ?? [], aliases),
+        ...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.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.yellow("\nFix mode\n"));
+
+    // add new events
+    for (const [name] of newEvents) {
+      config.events.push(name);
+      console.log(chalk.green(`+ ${name}`));
+    }
+
+    // resolve dynamic
+    for (const [value] of unresolvedDynamic) {
+      const { action } = await inquirer.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.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.green(`${value} → ${normalized}`));
+    }
+
+    config.aliases = Object.fromEntries(
+      Object.entries(aliases).sort()
+    );
+
+    config.events = [...new Set(config.events)].sort();
+
+    await saveConfig(config);
+
+    console.log(chalk.green("\n✔ Fixed"));
+    return;
+  }
+
+  // NORMAL MODE
+  let hasError = false;
+
+  if (unresolvedDynamic.size) {
+    hasError = true;
+
+    console.log(chalk.red("\nDynamic events:"));
+
+    unresolvedDynamic.forEach((e) =>
+      console.log(
+        chalk.red(`- ${e.value} (${e.file}:${e.line})`)
+      )
+    );
+  }
+
+  if (newEvents.size) {
+    hasError = true;
+
+    console.log(chalk.red("\nNew events:"));
+
+    newEvents.forEach((e) =>
+      console.log(
+        chalk.red(`+ ${e.value} (${e.file}:${e.line})`)
+      )
+    );
+  }
+
+  if (hasError) {
+    console.log(chalk.red("\nEvent check failed"));
+    process.exit(1);
+  }
+
+  console.log(chalk.green("\nAll good"));
+}

package/src/commands/sync.ts

@@ -1,157 +1,217 @@
 import chalk from "chalk";
 import fg from "fast-glob";
-import { Project } from "ts-morph";
+import {Project} from "ts-morph";
 import fs from "fs/promises";
 import inquirer from "inquirer";
 
-import {
-  loadConfig,
-  saveConfig
-} from "../utils/config";
+import {loadConfig, saveConfig} from "../utils/config";
 
-import { detectParser } from "../utils/parsers/router";
-import { parseVue } from "../utils/parsers/vue";
-import { parseSvelte } from "../utils/parsers/svelte";
-import { parseAstro } from "../utils/parsers/astro";
+import {detectWrappers} from "../utils/detect-wrappers";
+import {detectAliases} from "../utils/detect-aliases";
 
-import { scanTrack } from "../utils/scanners/track";
-import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
-import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
+import {detectParser} from "../utils/parsers/router";
+import {parseVue} from "../utils/parsers/vue";
+import {parseSvelte} from "../utils/parsers/svelte";
+import {parseAstro} from "../utils/parsers/astro";
 
-import { ExtractedEvent } from "../types";
+import {scanTrack} from "../utils/scanners/track";
+import {scanFunctionWrappers} from "../utils/scanners/function-wrappers";
+import {scanComponentWrappers} from "../utils/scanners/component-wrappers";
+
+import {ExtractedEvent} from "../types";
 
 export async function sync() {
   const config = await loadConfig();
 
   if (!config) {
-    console.log(
-      chalk.red("Run 'eventra init'")
-    );
+    console.log(chalk.red("Run 'eventra init'"));
     return;
   }
 
-  console.log(
-    chalk.blue("Scanning project...")
-  );
+  console.log(chalk.blue("Scanning project..."));
 
   const project = new Project();
-  const events = new Set<string>();
 
+  const events = new Set<string>();
   const aliases = config.aliases ?? {};
   const asked = new Set<string>();
 
-  const files = await fg(
-    config.sync.include,
-    {
-      ignore: config.sync.exclude
-    }
-  );
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude
+  });
 
   for (const file of files) {
-    const parser = detectParser(file);
-
-    let content = await fs.readFile(
-      file,
-      "utf-8"
-    );
-
-    if (parser === "vue")
-      content = parseVue(content);
-
-    if (parser === "svelte")
-      content = parseSvelte(content);
-
-    if (parser === "astro")
-      content = parseAstro(content);
-
-    const virtualFile =
-      parser === "ts"
-        ? file
-        : file + ".tsx";
-
-    const source = project.createSourceFile(
-      virtualFile,
-      content,
-      { overwrite: true }
-    );
-
-    const found: ExtractedEvent[] = [
-      ...scanTrack(source, config),
-      ...scanFunctionWrappers(
-        source,
-        config.functionWrappers ?? []
-      ),
-      ...scanComponentWrappers(
-        source,
-        config.wrappers ?? []
-      )
-    ];
-
-    for (const event of found) {
-      const { value, dynamic } = event;
-
-      if (!value) continue;
-
-      // alias
-      if (aliases[value]) {
-        console.log(
-          chalk.gray(`alias: ${value} → ${aliases[value]}`)
-        );
-        events.add(aliases[value]);
-        continue;
+    try {
+      const parser = detectParser(file);
+
+      let content = await fs.readFile(file, "utf-8");
+
+      if (parser === "vue") content = parseVue(content);
+      if (parser === "svelte") content = parseSvelte(content);
+      if (parser === "astro") content = parseAstro(content);
+
+      const virtualFile =
+        parser === "ts" ? file : file + ".tsx";
+
+      const source = project.createSourceFile(
+        virtualFile,
+        content,
+        {overwrite: true}
+      );
+
+
+      // AUTO ALIASES
+      const detectedAliases = detectAliases(source);
+
+      for (const key in detectedAliases) {
+        if (!(key in aliases)) {
+          aliases[key] = detectedAliases[key];
+
+          console.log(
+            chalk.green(
+              `Detected alias: ${key} → ${detectedAliases[key]}`
+            )
+          );
+        }
       }
 
-      // static
-      if (!dynamic) {
-        events.add(value);
-        continue;
+
+      // AUTO WRAPPERS
+      const detected = 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.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.green(
+              `Detected component wrapper: ${comp.name} (prop: ${comp.prop})`
+            )
+          );
+        }
       }
 
-      // ask user
-      console.log(
-        chalk.yellow("\nDynamic event detected:")
-      );
-      console.log(chalk.gray(value));
-
-      const { name } = await inquirer.prompt([
-        {
-          type: "input",
-          name: "name",
-          message:
-            "Enter event name (or type 'skip'):"
+      // SCAN EVENTS
+      const found: ExtractedEvent[] = [
+        ...scanTrack(source, config, aliases),
+        ...scanFunctionWrappers(
+          source,
+          config.functionWrappers ?? [],
+          aliases
+        ),
+        ...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;
+        }
+
+        // static
+        if (!dynamic) {
+          events.add(value);
+          continue;
         }
-      ]);
 
-      const normalized = name?.trim();
+        // already handled
+        if (asked.has(value)) continue;
 
-      asked.add(value);
+        // ASK ONLY IF NEEDED
+        console.log(
+          chalk.yellow("\nDynamic event detected:")
+        );
+        console.log(chalk.gray(value));
+
+        const {name} = await inquirer.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.green(
+            `Saved alias: ${value} → ${normalized}`
+          )
+        );
 
-      if (!normalized || normalized === "skip") {
-        continue;
+        events.add(normalized);
       }
 
-      // save alias
-      aliases[value] = normalized;
+      // free memory
+      project.removeSourceFile(source);
 
-      events.add(normalized);
+    } catch {
+      console.log(
+        chalk.gray(`Skipped file: ${file}`)
+      );
     }
   }
+  // SAVE CONFIG
+  config.aliases = Object.fromEntries(
+    Object.entries(aliases).sort()
+  );
 
-  config.aliases = aliases;
+  // MERGE
+  const merged = new Set([
+    ...config.events,
+    ...events
+  ]);
 
-  const list = [...events].sort();
-  config.events = list;
+  config.events = [...merged].sort();
 
   await saveConfig(config);
 
   console.log(
-    chalk.green(
-      `Found ${list.length} events`
-    )
+    chalk.green(`\nFound ${config.events.length} events`)
   );
 }

package/src/commands/watch.ts

@@ -0,0 +1,113 @@
+import chokidar from "chokidar";
+import chalk from "chalk";
+import { Project } from "ts-morph";
+import fs from "fs/promises";
+
+import { loadConfig, saveConfig } from "../utils/config";
+
+import { detectParser } from "../utils/parsers/router";
+import { parseVue } from "../utils/parsers/vue";
+import { parseSvelte } from "../utils/parsers/svelte";
+import { parseAstro } from "../utils/parsers/astro";
+
+import { scanTrack } from "../utils/scanners/track";
+import { scanFunctionWrappers } from "../utils/scanners/function-wrappers";
+import { scanComponentWrappers } from "../utils/scanners/component-wrappers";
+
+export async function watch() {
+  const config = await loadConfig();
+
+  if (!config) {
+    console.log(chalk.red("Run init first"));
+    return;
+  }
+
+  console.log(chalk.blue("Watching...\n"));
+
+  const project = new Project();
+
+  const aliases = config.aliases ?? {};
+
+  // уже известные события
+  const seen = new Set(config.events);
+
+  const queue = new Set<string>();
+  let timer: NodeJS.Timeout;
+
+  const processQueue = async () => {
+    const files = [...queue];
+    queue.clear();
+
+    for (const file of files) {
+      await handle(file);
+    }
+
+    config.events = [...new Set(config.events)].sort();
+
+    await saveConfig(config);
+  };
+
+  const handle = async (file: string) => {
+    try {
+      let content = await fs.readFile(file, "utf-8");
+
+      const parser = detectParser(file);
+
+      if (parser === "vue") content = parseVue(content);
+      if (parser === "svelte") content = parseSvelte(content);
+      if (parser === "astro") content = parseAstro(content);
+
+      const source = project.createSourceFile(file, content, {
+        overwrite: true
+      });
+
+      const found = [
+        ...scanTrack(source, config, aliases),
+        ...scanFunctionWrappers(source, config.functionWrappers ?? [], aliases),
+        ...scanComponentWrappers(source, config.wrappers ?? [], aliases)
+      ];
+
+      for (const e of found) {
+        if (!e.value) continue;
+
+        if (aliases[e.value] === "__skip__") continue;
+
+        if (e.value in aliases) continue;
+
+        if (seen.has(e.value)) continue;
+
+        seen.add(e.value);
+
+        if (!e.dynamic) {
+          config.events.push(e.value);
+          console.log(chalk.green(`+ ${e.value}`));
+        } else {
+          console.log(chalk.yellow(`Dynamic: ${e.value}`));
+        }
+      }
+
+      project.removeSourceFile(source);
+
+    } catch {
+      console.log(chalk.gray(`skip: ${file}`));
+    }
+  };
+
+  const watcher = chokidar.watch(config.sync.include, {
+    ignored: [
+      ...config.sync.exclude,
+      "**/*.log",
+      "**/*.tmp",
+      "**/*.swp"
+    ],
+    ignoreInitial: true
+  });
+
+  watcher.on("change", (file) => {
+    queue.add(file);
+
+    clearTimeout(timer);
+
+    timer = setTimeout(processQueue, 200);
+  });
+}

package/src/index.ts

@@ -11,7 +11,6 @@ program
 
 program
   .command("init")
-  .description("Initialize Eventra")
   .action(async () => {
     const { init } = await import("./commands/init");
     await init();
@@ -19,15 +18,29 @@ program
 
 program
   .command("sync")
-  .description("Sync events")
   .action(async () => {
     const { sync } = await import("./commands/sync");
     await sync();
   });
 
+program
+  .command("check")
+  .option("--fix", "auto fix issues")
+  .action(async (opts) => {
+    const { check } = await import("./commands/check");
+    await check({ fix: opts.fix });
+  });
+
+program
+  .command("watch")
+  .description("Watch files and detect events in real-time")
+  .action(async () => {
+    const { watch } = await import("./commands/watch");
+    await watch();
+  });
+
 program
   .command("send")
-  .description("Send events")
   .action(async () => {
     const { send } = await import("./commands/send");
     await send();

package/src/types.ts

@@ -6,6 +6,8 @@ export type ComponentWrapper = {
 export type FunctionWrapper = {
   name: string;
   event?: string;
+  file?: string;
+  line?: number;
 };
 
 export type EventraConfig = {
@@ -24,4 +26,6 @@ export type EventraConfig = {
 export type ExtractedEvent = {
   value: string;
   dynamic: boolean;
+  file?: string;
+  line?: number;
 };