@eventra_dev/eventra-cli 0.1.33 → 0.2.1

package/src/commands/watch.ts

@@ -9,92 +9,39 @@ import { EventraEngine } from "../engine/engine";
 import { processFile } from "../utils/processFile";
 import { getVirtualFile } from "../utils/getVirtualFile";
 
-type QueueItem = {
-  real: string;
-  virtual: string;
-};
-
-function normalize(file: string) {
-  return path.resolve(file).replace(/\\/g, "/");
-}
-
 export async function watch() {
   const config = await loadConfig();
   if (!config) return;
 
   console.log(chalk.blue("Watching...\n"));
 
-  const files = await fg(config.sync.include, {
-    ignore: config.sync.exclude,
-    absolute: true,
-  });
-
   const engine = new EventraEngine(process.cwd());
+  const fileDeps = new Map<string, Set<string>>();
+  const cache = new Map<string, { content: string; deps: string[] }>();
   const watchedDeps = new Set<string>();
 
-  const cache = new Map<
-    string,
-    { content: string; deps: string[] }
-  >();
+  const normalize = (f: string) =>
+    path.resolve(f).replace(/\\/g, "/");
 
-  const toScan = new Set<string>();
+  // INITIAL LOAD
+  const files = await fg(config.sync.include, {
+    ignore: config.sync.exclude,
+    absolute: true,
+  });
 
-  // COLLECT + CACHE
   for (const file of files) {
     try {
       const abs = normalize(file);
       const raw = await fs.readFile(abs, "utf-8");
 
-      if (raw.length > 2_000_000) continue;
-
       const parsed = processFile(abs, raw);
 
       cache.set(abs, parsed);
-      toScan.add(abs);
 
-      for (const dep of parsed.deps) {
-        toScan.add(normalize(dep));
-      }
+      engine.preloadFile(getVirtualFile(abs), parsed.content);
+      engine.updateFile(getVirtualFile(abs), parsed.content, config);
 
-    } catch {
-      console.log(chalk.gray(`skip: ${file}`));
-    }
-  }
-
-  // PRELOAD
-  for (const file of toScan) {
-    try {
-      let parsed = cache.get(file);
-
-      if (!parsed) {
-        const raw = await fs.readFile(file, "utf-8");
-        parsed = processFile(file, raw);
-        cache.set(file, parsed);
-      }
-
-      const virtual = getVirtualFile(file);
-      engine.preloadFile?.(virtual, parsed.content);
-
-    } catch {}
-  }
-
-  // INITIAL SCAN
-  for (const file of toScan) {
-    try {
-      let parsed = cache.get(file);
-
-      if (!parsed) {
-        const raw = await fs.readFile(file, "utf-8");
-        parsed = processFile(file, raw);
-      }
-
-      const virtual = getVirtualFile(file);
-
-      engine.scanFile(virtual, parsed.content, config);
-
-      for (const dep of parsed.deps) {
-        watchedDeps.add(normalize(dep));
-      }
+      fileDeps.set(abs, new Set(parsed.deps.map(d => normalize(d))));
 
     } catch {}
   }
@@ -102,152 +49,95 @@ export async function watch() {
   config.events = engine.getAllEvents().sort();
   await saveConfig(config);
 
-  console.log(
-    chalk.gray(`Initial: ${config.events.length} events\n`)
+  console.log(chalk.gray(`Initial: ${config.events.length}\n`));
+
+  // WATCHER
+  const watcher = chokidar.watch(
+    [...files.map(normalize), ...watchedDeps],
+    { ignoreInitial: true }
   );
 
-  // QUEUE
-  let locked = false;
-  const queued = new Map<string, QueueItem>();
+  const queue = new Map<string, boolean>();
   let timer: NodeJS.Timeout | null = null;
 
   const run = async () => {
-    if (locked) return;
-    locked = true;
+    const batch = [...queue.keys()];
+    queue.clear();
 
-    const batch = [...queued.values()];
-    queued.clear();
-
-    for (const item of batch) {
+    for (const file of batch) {
       try {
-        const raw = await fs.readFile(item.real, "utf-8");
-
-        if (raw.length > 2_000_000) continue;
+        const raw = await fs.readFile(file, "utf-8");
+        const parsed = processFile(file, raw);
 
-        const parsed = processFile(item.real, raw);
-        cache.set(item.real, parsed);
+        cache.set(file, parsed);
 
-        engine.updateFile(item.virtual, parsed.content, config);
+        engine.updateFile(
+          getVirtualFile(file),
+          parsed.content,
+          config
+        );
 
-        // DEPENDENCY DIFF
-        const nextDeps = new Set<string>();
+        //dependency diff
+        const abs = normalize(file);
 
-        for (const dep of parsed.deps) {
-          nextDeps.add(normalize(dep));
-        }
+        const prevDeps = fileDeps.get(abs) ?? new Set();
+        const nextDeps = new Set(parsed.deps.map(d => normalize(d)));
 
         // add new deps
         for (const dep of nextDeps) {
-          if (!watchedDeps.has(dep)) {
+          if (!prevDeps.has(dep)) {
             watcher.add(dep);
             watchedDeps.add(dep);
           }
         }
 
         // remove old deps
-        for (const dep of [...watchedDeps]) {
+        for (const dep of prevDeps) {
           if (!nextDeps.has(dep)) {
             watcher.unwatch(dep);
             watchedDeps.delete(dep);
           }
         }
 
-        // preload deps
-        for (const dep of nextDeps) {
-          try {
-            const raw = await fs.readFile(dep, "utf-8");
-            const parsedDep = processFile(dep, raw);
-
-            cache.set(dep, parsedDep);
-
-            const virtual = getVirtualFile(dep);
-
-            engine.updateFile(virtual, parsedDep.content, config);
-          } catch {}
-        }
+        fileDeps.set(abs, nextDeps);
 
       } catch {
-        console.log(chalk.gray(`skip: ${item.real}`));
+        console.log(chalk.gray(`skip: ${file}`));
       }
     }
 
-    // DIFF EVENTS
-    const next = engine.getAllEvents();
-
-    const added = next.filter(e => !config.events.includes(e));
-    const removed = config.events.filter(e => !next.includes(e));
-
-    if (added.length || removed.length) {
-      added.forEach(e => console.log(chalk.green(`+ ${e}`)));
-      removed.forEach(e => console.log(chalk.red(`- ${e}`)));
+    const next = engine.getAllEvents().sort();
+    config.events = next;
 
-      config.events = next.sort();
-      await saveConfig(config);
-
-      console.log(
-        chalk.gray(`Total: ${config.events.length} events\n`)
-      );
-    }
+    await saveConfig(config);
 
-    locked = false;
+    console.log(chalk.green(`Updated: ${next.length}`));
   };
 
-  // SCHEDULER
   const schedule = (file: string) => {
     const abs = normalize(file);
-    const virtual = getVirtualFile(abs);
-
-    console.log(chalk.gray(`change: ${file}`));
-
-    queued.set(abs, { real: abs, virtual });
+    queue.set(abs, true);
 
     if (timer) clearTimeout(timer);
     timer = setTimeout(run, 200);
   };
 
-  // WATCHER
-  const watcher = chokidar.watch(config.sync.include, {
-    ignored: config.sync.exclude,
-    ignoreInitial: true,
-    persistent: true,
-  });
-
   watcher
-    .on("add", schedule)
     .on("change", schedule)
+    .on("add", schedule)
     .on("unlink", async (file) => {
       const abs = normalize(file);
 
-      console.log(chalk.gray(`remove: ${file}`));
-
-      const virtual = getVirtualFile(abs);
-
-      engine.removeFile(virtual, config);
+      engine.removeFile(getVirtualFile(abs), config);
 
-      watcher.unwatch(abs);
-      watchedDeps.delete(abs);
-
-      const next = engine.getAllEvents();
-
-      config.events = next.sort();
+      const next = engine.getAllEvents().sort();
+      config.events = next;
       await saveConfig(config);
 
-      console.log(
-        chalk.gray(`Total: ${config.events.length} events\n`)
-      );
-    })
-    .on("error", (err) => {
-      console.error(chalk.red("Watcher error:"), err);
+      console.log(chalk.red(`Removed → ${next.length}`));
     });
 
-  // WATCH DEPS INIT
-  for (const dep of watchedDeps) {
-    watcher.add(dep);
-  }
-
-  // EXIT
   process.on("SIGINT", async () => {
-    console.log(chalk.yellow("\nStopping watcher..."));
     await watcher.close();
     process.exit(0);
   });

package/src/engine/callResolver.ts

@@ -1,200 +1,65 @@
 import ts from "typescript";
 
-// HELPERS
-function isFunctionLike(
-  node: ts.Node
-): node is ts.FunctionLikeDeclaration {
+function isFn(node: ts.Node): node is ts.FunctionLikeDeclaration {
   return (
     ts.isFunctionDeclaration(node) ||
     ts.isMethodDeclaration(node) ||
-    ts.isConstructorDeclaration(node) ||
     ts.isFunctionExpression(node) ||
     ts.isArrowFunction(node)
   );
 }
 
-// symbol → function
 function resolveFromSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
-  visited = new Set<ts.Symbol>(),
-  depth = 0
+  seen = new Set<ts.Symbol>()
 ): ts.FunctionLikeDeclaration | null {
-  if (!symbol) return null;
-  if (visited.has(symbol)) return null;
-  if (depth > 10) return null;
+  if (seen.has(symbol)) return null;
+  seen.add(symbol);
 
-  visited.add(symbol);
-
-  // Alias unwrap (import/export)
   if (symbol.flags & ts.SymbolFlags.Alias) {
-    try {
-      const aliased = checker.getAliasedSymbol(symbol);
-      return resolveFromSymbol(aliased, checker, visited, depth + 1);
-    } catch {}
+    return resolveFromSymbol(checker.getAliasedSymbol(symbol), checker, seen);
   }
 
-  // Declarations
-  const decls = symbol.getDeclarations() ?? [];
+  for (const d of symbol.getDeclarations() ?? []) {
+    if (isFn(d)) return d;
 
-  for (const decl of decls) {
-    /**
-     * direct function
-     */
-    if (isFunctionLike(decl)) {
-      return decl;
-    }
+    if (ts.isVariableDeclaration(d) && d.initializer) {
+      if (isFn(d.initializer)) return d.initializer;
 
-    // VARIABLE → FUNCTION const fn = () => {}
-    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      if (isFunctionLike(decl.initializer)) {
-        return decl.initializer;
+      const s = checker.getSymbolAtLocation(d.initializer);
+      if (s) {
+        const r = resolveFromSymbol(s, checker, seen);
+        if (r) return r;
       }
-
-      const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
-      if (innerSymbol && innerSymbol !== symbol) {
-        const resolved = resolveFromSymbol(
-          innerSymbol,
-          checker,
-          visited,
-          depth + 1
-        );
-        if (resolved) return resolved;
-      }
-    }
-
-    // CLASS METHOD
-    if (ts.isMethodDeclaration(decl)) {
-      return decl;
-    }
-
-    // interface / type method
-    if (ts.isMethodSignature(decl)) {
-      const parent = decl.parent;
-
-      if (
-        ts.isInterfaceDeclaration(parent) ||
-        ts.isTypeLiteralNode(parent)
-      ) {
-        const type = checker.getTypeAtLocation(parent);
-        const props = type.getProperties();
-
-        for (const prop of props) {
-          const resolved = resolveFromSymbol(
-            prop,
-            checker,
-            visited,
-            depth + 1
-          );
-          if (resolved) return resolved;
-        }
-      }
-    }
-
-    // fallback recursion
-    const inner = checker.getSymbolAtLocation(decl);
-    if (inner && inner !== symbol) {
-      const resolved = resolveFromSymbol(
-        inner,
-        checker,
-        visited,
-        depth + 1
-      );
-      if (resolved) return resolved;
-    }
-  }
-
-  // Exports (re-export)
-  const exports = (symbol as any).exports;
-  if (exports) {
-    for (const exp of exports.values()) {
-      const resolved = resolveFromSymbol(
-        exp,
-        checker,
-        visited,
-        depth + 1
-      );
-      if (resolved) return resolved;
     }
   }
 
   return null;
 }
 
-// MAIN FUNCTION
 export function resolveFunctionFromCall(
   expr: ts.Expression,
   checker: ts.TypeChecker
 ): ts.FunctionLikeDeclaration | null {
-  // obj.method()
+  // foo.bar()
   if (ts.isPropertyAccessExpression(expr)) {
-    let symbol = checker.getSymbolAtLocation(expr.name);
-
-    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-      try {
-        symbol = checker.getAliasedSymbol(symbol);
-      } catch {}
-    }
-
-    if (symbol) {
-      const resolved = resolveFromSymbol(symbol, checker);
-      if (resolved) return resolved;
+    const s = checker.getSymbolAtLocation(expr.name);
+    if (s) {
+      const r = resolveFromSymbol(s, checker);
+      if (r) return r;
     }
   }
 
-  // obj["method"]()
-  if (ts.isElementAccessExpression(expr)) {
-    const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
-
-    if (symbol) {
-      const resolved = resolveFromSymbol(symbol, checker);
-      if (resolved) return resolved;
-    }
-  }
-
-  // Call signatures
+  // direct call
   const type = checker.getTypeAtLocation(expr);
-  const signatures = type.getCallSignatures();
-
-  for (const sig of signatures) {
-    const decl = sig.getDeclaration();
-    if (!decl) continue;
-
-    if (isFunctionLike(decl)) {
-      return decl;
-    }
-
-    if (ts.isMethodSignature(decl)) {
-      const symbol = checker.getSymbolAtLocation(decl.name);
-
-      if (symbol) {
-        const resolved = resolveFromSymbol(symbol, checker);
-        if (resolved) return resolved;
-      }
-    }
+  for (const sig of type.getCallSignatures()) {
+    const d = sig.getDeclaration();
+    if (d && isFn(d)) return d;
   }
 
-  // Identifier fallback
-  if (ts.isIdentifier(expr)) {
-    let symbol = checker.getSymbolAtLocation(expr);
-
-    if (symbol && (symbol.flags & ts.SymbolFlags.Alias)) {
-      try {
-        symbol = checker.getAliasedSymbol(symbol);
-      } catch {}
-    }
-
-    if (symbol) {
-      const resolved = resolveFromSymbol(symbol, checker);
-      if (resolved) return resolved;
-    }
-  }
-
-  // LAST fallback
-  const symbol = checker.getSymbolAtLocation(expr);
-  if (symbol) {
-    return resolveFromSymbol(symbol, checker);
-  }
+  const s = checker.getSymbolAtLocation(expr);
+  if (s) return resolveFromSymbol(s, checker);
 
   return null;
 }

package/src/engine/engine.ts

@@ -5,7 +5,7 @@ import { TSService } from "./languageService";
 import { scanSource } from "./scanner";
 import { DependencyGraph } from "./graph";
 import { hash } from "./hash";
-import {EventraConfig, ScanResult} from "../types";
+import { EventraConfig, ScanResult } from "../types";
 import { isExternalFile } from "./boundary";
 
 export class EventraEngine {
@@ -46,7 +46,7 @@ export class EventraEngine {
     }
   }
 
-  // SCAN FILE
+  // SCAN FILE (cached)
   scanFile(
     file: string,
     content: string,
@@ -71,7 +71,6 @@ export class EventraEngine {
       return this.empty();
     }
 
-    // update graph
     this.graph.update(file, source);
 
     const res = scanSource(
@@ -82,6 +81,7 @@ export class EventraEngine {
       undefined,
       this.wrapperCache
     );
+
     this.fileResults.set(file, res);
 
     return res;
@@ -92,10 +92,17 @@ export class EventraEngine {
     file: string,
     content: string,
     config: EventraConfig
-  ) {
-    this.wrapperCache.clear();
+  ): ScanResult {
     file = this.normalize(file);
 
+    // EARLY EXIT
+    if (this.fileHash.get(file) === hash(content)) {
+      return this.fileResults.get(file) ?? this.empty();
+    }
+
+    // invalidate wrapper cache
+    this.wrapperCache.clear();
+
     const res = this.scanFile(file, content, config);
 
     const dependents = this.graph.getAllDependentsDeep(file);
@@ -103,6 +110,7 @@ export class EventraEngine {
     for (const dep of dependents) {
       const abs = this.normalize(dep);
 
+      if (abs === file) continue; // self-skip
       if (isExternalFile(abs)) continue;
 
       let depContent = this.ts.getFileContent(abs);
@@ -140,6 +148,7 @@ export class EventraEngine {
         undefined,
         this.wrapperCache
       );
+
       this.fileResults.set(abs, r);
     }
 
@@ -159,19 +168,22 @@ export class EventraEngine {
 
   // REMOVE FILE
   removeFile(file: string, config?: EventraConfig) {
-    this.wrapperCache.clear();
     file = this.normalize(file);
 
+    this.wrapperCache.clear();
+
     const dependents = this.graph.getAllDependentsDeep(file);
 
+    this.graph.remove(file);
+
     this.ts.removeFile(file);
     this.fileResults.delete(file);
     this.fileHash.delete(file);
-    this.graph.remove(file);
 
     for (const dep of dependents) {
       const abs = this.normalize(dep);
 
+      if (abs === file) continue;
       if (isExternalFile(abs)) continue;
 
       let content = this.ts.getFileContent(abs);
@@ -184,11 +196,7 @@ export class EventraEngine {
         }
       }
 
-      const h = hash(content);
-
-      if (this.fileHash.get(abs) === h) continue;
-
-      this.fileHash.set(abs, h);
+      this.fileHash.delete(abs);
 
       this.ts.updateFile(abs, content);