@eventra_dev/eventra-cli 0.1.2 → 0.1.4

package/src/engine/graph.ts

@@ -1,23 +1,110 @@
 import ts from "typescript";
+import path from "path";
+import fs from "fs";
 
 export class DependencyGraph {
   private reverse = new Map<string, Set<string>>();
+  private exports = new Map<string, Set<string>>();
+
+  private normalize(file: string) {
+    return path.resolve(file);
+  }
+
+  private resolveImport(from: string, module: string): string | null {
+    if (!module.startsWith(".")) return null;
+
+    const base = path.resolve(path.dirname(from), module);
+
+    const tryFiles = [
+      base,
+      base + ".ts",
+      base + ".tsx",
+      base + ".js",
+      base + ".jsx",
+      path.join(base, "index.ts"),
+      path.join(base, "index.tsx"),
+      path.join(base, "index.js"),
+    ];
+
+    for (const f of tryFiles) {
+      if (fs.existsSync(f)) {
+        return this.normalize(f);
+      }
+    }
+
+    return this.normalize(base);
+  }
 
   update(file: string, source: ts.SourceFile) {
+    const normalizedFile = this.normalize(file);
+
+    this.exports.set(normalizedFile, new Set());
+
     for (const stmt of source.statements) {
-      if (!ts.isImportDeclaration(stmt)) continue;
+      // IMPORT
+      if (ts.isImportDeclaration(stmt)) {
+        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+        const resolved = this.resolveImport(normalizedFile, module);
+
+        if (!resolved) continue;
+
+        if (!this.reverse.has(resolved)) {
+          this.reverse.set(resolved, new Set());
+        }
+
+        this.reverse.get(resolved)!.add(normalizedFile);
+      }
 
-      const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+      // EXPORT
+      if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) {
+        const module = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+        const resolved = this.resolveImport(normalizedFile, module);
 
-      if (!this.reverse.has(module)) {
-        this.reverse.set(module, new Set());
+        if (!resolved) continue;
+
+        if (!this.exports.has(normalizedFile)) {
+          this.exports.set(normalizedFile, new Set());
+        }
+
+        this.exports.get(normalizedFile)!.add(resolved);
+
+        if (!this.reverse.has(resolved)) {
+          this.reverse.set(resolved, new Set());
+        }
+
+        this.reverse.get(resolved)!.add(normalizedFile);
       }
+    }
+  }
+
+  getAllRelated(file: string, visited = new Set<string>()): Set<string> {
+    const normalized = this.normalize(file);
+
+    if (visited.has(normalized)) return visited;
+    visited.add(normalized);
 
-      this.reverse.get(module)!.add(file);
+    const deps = this.exports.get(normalized);
+
+    if (!deps) return visited;
+
+    for (const dep of deps) {
+      this.getAllRelated(dep, visited);
     }
+
+    return visited;
   }
 
   getDependents(file: string) {
-    return [...(this.reverse.get(file) ?? [])];
+    return [...(this.reverse.get(this.normalize(file)) ?? [])];
+  }
+
+  remove(file: string) {
+    const normalized = this.normalize(file);
+
+    this.exports.delete(normalized);
+
+    for (const set of this.reverse.values()) {
+      set.delete(normalized);
+    }
   }
 }

package/src/engine/languageService.ts

@@ -3,13 +3,49 @@ import fs from "fs";
 
 export class TSService {
   private files = new Map<string, { version: number; content: string }>();
+  private fileNames = new Set<string>();
   private service: ts.LanguageService;
 
   constructor(private root: string) {
+    const configPath = ts.findConfigFile(
+      root,
+      ts.sys.fileExists,
+      "tsconfig.json"
+    );
+
+    let compilerOptions: ts.CompilerOptions = {
+      allowJs: true,
+      jsx: ts.JsxEmit.Preserve,
+      moduleResolution: ts.ModuleResolutionKind.Node16,
+      target: ts.ScriptTarget.ESNext,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+    };
+
+    if (configPath) {
+      const configFile = ts.readConfigFile(
+        configPath,
+        ts.sys.readFile
+      );
+
+      const parsed = ts.parseJsonConfigFileContent(
+        configFile.config,
+        ts.sys,
+        root
+      );
+
+      compilerOptions = {
+        ...compilerOptions,
+        ...parsed.options,
+      };
+    }
+
     const host: ts.LanguageServiceHost = {
-      getScriptFileNames: () => [...this.files.keys()],
+      getScriptFileNames: () => [...this.fileNames],
+
       getScriptVersion: (file) =>
         this.files.get(file)?.version.toString() ?? "0",
+
       getScriptSnapshot: (file) => {
         const f = this.files.get(file);
 
@@ -19,32 +55,21 @@ export class TSService {
 
         if (fs.existsSync(file)) {
           return ts.ScriptSnapshot.fromString(
-            fs.readFileSync(file, "utf-8" as BufferEncoding)
+            fs.readFileSync(file, "utf-8")
           );
         }
 
         return undefined;
       },
+
       getCurrentDirectory: () => this.root,
-      getCompilationSettings: () => ({
-        allowJs: true,
-        jsx: ts.JsxEmit.Preserve,
-        moduleResolution: ts.ModuleResolutionKind.Node16,
-        target: ts.ScriptTarget.ESNext,
-        esModuleInterop: true,
-        allowSyntheticDefaultImports: true,
-      }),
-      getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
-
-      readFile: (fileName: string, encoding?: string) => {
-        try {
-          return fs.readFileSync(fileName, encoding as BufferEncoding);
-        } catch (err) {
-          return undefined;
-        }
-      },
+      getCompilationSettings: () => compilerOptions,
+      getDefaultLibFileName: (opts) =>
+        ts.getDefaultLibFilePath(opts),
 
-      fileExists: fs.existsSync,
+      readFile: ts.sys.readFile,
+      fileExists: ts.sys.fileExists,
+      readDirectory: ts.sys.readDirectory,
     };
 
     this.service = ts.createLanguageService(host);
@@ -57,6 +82,8 @@ export class TSService {
       content,
       version: prev ? prev.version + 1 : 1,
     });
+
+    this.fileNames.add(file);
   }
 
   getProgram() {

package/src/engine/resolver.ts

@@ -7,9 +7,23 @@ export type ResolveResult = {
 
 export function resolveNodeValue(
   node: ts.Node,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  paramMap?: Map<string, ts.Expression>,
+  seen = new Set<ts.Node>()
 ): ResolveResult | null {
 
+  if (seen.has(node)) return null;
+  seen.add(node);
+
+  // param mapping
+  if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
+    return resolveNodeValue(
+      paramMap.get(node.text)!,
+      checker,
+      paramMap
+    );
+  }
+
   if (ts.isStringLiteral(node)) {
     return { values: [node.text], dynamic: false };
   }
@@ -26,8 +40,8 @@ export function resolveNodeValue(
   }
 
   if (ts.isConditionalExpression(node)) {
-    const a = resolveNodeValue(node.whenTrue, checker);
-    const b = resolveNodeValue(node.whenFalse, checker);
+    const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
+    const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
 
     return {
       values: [...new Set([...(a?.values ?? []), ...(b?.values ?? [])])],
@@ -45,7 +59,7 @@ export function resolveNodeValue(
 
     for (const decl of symbol.getDeclarations() ?? []) {
       if (ts.isVariableDeclaration(decl) && decl.initializer) {
-        return resolveNodeValue(decl.initializer, checker);
+        return resolveNodeValue(decl.initializer, checker, paramMap, seen);
       }
 
       if (ts.isEnumMember(decl) && decl.initializer) {
@@ -82,5 +96,38 @@ export function resolveNodeValue(
     }
   }
 
+  if (ts.isObjectLiteralExpression(node)) {
+    const values: string[] = [];
+
+    for (const prop of node.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
+
+      const name = prop.name.getText();
+
+      if (name === "event") {
+        const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
+        if (res) values.push(...res.values);
+      }
+    }
+
+    return { values, dynamic: true };
+  }
+
+  if (ts.isBinaryExpression(node)) {
+    if (node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      const left = resolveNodeValue(node.left, checker, paramMap, seen);
+      const right = resolveNodeValue(node.right, checker, paramMap, seen);
+
+      if (left && right) {
+        return {
+          values: left.values.flatMap(l =>
+            right.values.map(r => l + r)
+          ),
+          dynamic: true,
+        };
+      }
+    }
+  }
+
   return null;
 }

package/src/engine/scanner.ts

@@ -1,12 +1,52 @@
 import ts from "typescript";
 import { resolveNodeValue } from "./resolver";
 import { resolveFunctionFromCall } from "./callResolver";
+import { findTrackParamIndex } from "./functionAnalyzer";
+
+function getCallName(expr: ts.Expression): string {
+  if (ts.isIdentifier(expr)) return expr.text;
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+
+  return "";
+}
+
+function pickBestArg(
+  args: readonly ts.Expression[],
+  checker: ts.TypeChecker,
+  paramMap: Map<string, ts.Expression>
+) {
+  let best: { score: number; node: ts.Expression } | null = null;
+
+  for (const arg of args) {
+    const res = resolveNodeValue(arg, checker, paramMap);
+
+    if (!res?.values?.length) continue;
+
+    let score = 0;
+
+    if (!res.dynamic) score += 3;
+    if (res.values.every(v => v.length < 50)) score += 2;
+    if (res.values.some(v => v.includes("*"))) score -= 2;
+
+    if (!best || score > best.score) {
+      best = { score, node: arg };
+    }
+  }
+
+  return best?.node;
+}
 
 export function scanSource(
   source: ts.SourceFile,
   checker: ts.TypeChecker,
-  visited = new Set<string>()
-) {
+  visited = new Set<string>(),
+  depth = 0
+): Set<string> {
+  if (depth > 5) return new Set();
+
   const events = new Set<string>();
 
   if (visited.has(source.fileName)) return events;
@@ -17,24 +57,61 @@ export function scanSource(
       const name = getCallName(node.expression);
 
       if (/(track|event|capture|send)/i.test(name)) {
-        let target = node.arguments[0];
-
         const fn = resolveFunctionFromCall(node.expression, checker);
 
-        // 🔥 cross-file
-        if (fn) {
-          const sf = fn.getSourceFile();
+        const paramMap = new Map<string, ts.Expression>();
+
+        if (fn && ts.isFunctionLike(fn)) {
+          fn.parameters.forEach((param, index) => {
+            const arg = node.arguments[index];
+            if (!arg) return;
+
+            if (ts.isIdentifier(param.name)) {
+              paramMap.set(param.name.text, arg);
+            }
+          });
+        }
+
+        if (fn && ts.isFunctionLike(fn)) {
+          const idx = findTrackParamIndex(fn);
+
+          if (idx !== null) {
+            const realArg = node.arguments[idx];
 
-          if (!visited.has(sf.fileName)) {
-            scanSource(sf, checker, visited).forEach(e => events.add(e));
+            if (realArg) {
+              const res = resolveNodeValue(realArg, checker, paramMap);
+
+              res?.values.forEach(v => {
+                if (
+                  v &&
+                  v.length > 1 &&
+                  v.length < 100 &&
+                  !v.includes(" ") &&
+                  /^[a-zA-Z0-9._:-]+$/.test(v)
+                ) {
+                  events.add(v);
+                }
+              });
+
+              return;
+            }
           }
         }
 
+        // fallback (heuristic)
+        const target = pickBestArg(node.arguments, checker, paramMap);
+
         if (target) {
-          const res = resolveNodeValue(target, checker);
+          const res = resolveNodeValue(target, checker, paramMap);
 
           res?.values.forEach(v => {
-            if (v && v.length > 1 && !v.includes(" ")) {
+            if (
+              v &&
+              v.length > 1 &&
+              v.length < 100 &&
+              !v.includes(" ") &&
+              /^[a-zA-Z0-9._:-]+$/.test(v)
+            ) {
               events.add(v);
             }
           });
@@ -49,13 +126,3 @@ export function scanSource(
 
   return events;
 }
-
-function getCallName(expr: ts.Expression): string {
-  if (ts.isIdentifier(expr)) return expr.text;
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.text;
-  }
-
-  return "";
-}

package/src/utils/config.ts

@@ -12,8 +12,7 @@ export function normalizeConfig(
     events: config.events ?? [],
     endpoint: config.endpoint ?? "",
     wrappers: config.wrappers ?? [],
-    functionWrappers:
-      config.functionWrappers ?? [],
+    functionWrappers: config.functionWrappers ?? [],
     aliases: config.aliases ?? {},
     sync: config.sync ?? {
       include: [
@@ -30,43 +29,26 @@ export function normalizeConfig(
 }
 
 export async function loadConfig(): Promise<EventraConfig | null> {
-  const configPath = path.join(
-    process.cwd(),
-    CONFIG_NAME
-  );
+  const configPath = path.join(process.cwd(), CONFIG_NAME);
 
-  if (
-    !(await fs.pathExists(
-      configPath
-    ))
-  ) {
+  if (!(await fs.pathExists(configPath))) {
     return null;
   }
 
-  const config =
-    await fs.readJSON(
-      configPath
-    );
-
-  return normalizeConfig(config);
+  try {
+    const config = await fs.readJSON(configPath);
+    return normalizeConfig(config);
+  } catch {
+    return null;
+  }
 }
 
-export async function saveConfig(
-  config: EventraConfig
-) {
-  const configPath = path.join(
-    process.cwd(),
-    CONFIG_NAME
-  );
+export async function saveConfig(config: EventraConfig) {
+  const configPath = path.join(process.cwd(), CONFIG_NAME);
 
-  const normalized =
-    normalizeConfig(config);
+  const normalized = normalizeConfig(config);
 
-  await fs.writeJSON(
-    configPath,
-    normalized,
-    {
-      spaces: 2
-    }
-  );
+  await fs.writeJSON(configPath, normalized, {
+    spaces: 2
+  });
 }

package/src/utils/parsers/astro.ts

@@ -1,5 +1,12 @@
-export function parseAstro(
-  content: string
-) {
-  return content;
+export function parseAstro(content: string) {
+  const frontmatter = content.match(/---([\s\S]*?)---/);
+
+  const scripts = [
+    ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+  ];
+
+  return [
+    frontmatter?.[1] ?? "",
+    ...scripts.map(s => s[1])
+  ].join("\n");
 }

package/src/utils/parsers/router.ts

@@ -1,14 +1,9 @@
-export function detectParser(
-  file: string
-) {
-  if (file.endsWith(".vue"))
-    return "vue";
+export function detectParser(file: string) {
+  file = file.toLowerCase();
 
-  if (file.endsWith(".svelte"))
-    return "svelte";
-
-  if (file.endsWith(".astro"))
-    return "astro";
+  if (file.endsWith(".vue")) return "vue";
+  if (file.endsWith(".svelte")) return "svelte";
+  if (file.endsWith(".astro")) return "astro";
 
   return "ts";
 }

package/src/utils/parsers/svelte.ts

@@ -1,5 +1,7 @@
-export function parseSvelte(
-  content: string
-) {
-  return content;
+export function parseSvelte(content: string) {
+  const scriptMatches = [
+    ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+  ];
+
+  return scriptMatches.map(m => m[1]).join("\n");
 }

package/src/utils/parsers/vue.ts

@@ -1,16 +1,26 @@
 export function parseVue(content: string) {
-  const scriptMatch = content.match(/<script[\s\S]*?>([\s\S]*?)<\/script>/);
-  const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
+  const scriptMatches = [
+    ...content.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)
+  ];
+
+  const script = scriptMatches.map(m => m[1]).join("\n");
 
-  const script = scriptMatch?.[1] ?? "";
+  // template
+  const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/);
   let template = templateMatch?.[1] ?? "";
 
   template = template.replace(/<!--[\s\S]*?-->/g, "");
 
+  // Vue → JSX
   template = template
+    .replace(/\bclass=/g, "className=")
+    .replace(/\bfor=/g, "htmlFor=")
+    .replace(/@(\w+)=/g, (_, e) => {
+      const name = e.charAt(0).toUpperCase() + e.slice(1);
+      return `on${name}=`;
+    })
     .replace(/v-if="[^"]+"/g, "")
-    .replace(/v-for="[^"]+"/g, "")
-    .replace(/@click=/g, "onClick=");
+    .replace(/v-for="[^"]+"/g, "");
 
   const jsx = `
 const __VUE_JSX__ = (

package/src/utils/processFile.ts

@@ -10,9 +10,12 @@ export function processFile(file: string, content: string) {
   if (parser === "svelte") content = parseSvelte(content);
   if (parser === "astro") content = parseAstro(content);
 
-  const virtualFile = file.endsWith(".vue")
-    ? file + ".tsx"
-    : file;
+  const virtualFile =
+    file.endsWith(".vue") ||
+    file.endsWith(".svelte") ||
+    file.endsWith(".astro")
+      ? file + ".tsx"
+      : file;
 
   return { content, virtualFile };
 }