@ape-egg/vibe 2.1.22 → 3.0.0

package/compiler/src/compiler/js_analyzer.rs

@@ -1,715 +0,0 @@
-use swc_common::{sync::Lrc, SourceMap, FileName};
-use swc_ecma_parser::{Parser, StringInput, Syntax, EsSyntax};
-use swc_ecma_ast::*;
-use swc_ecma_visit::{Visit, VisitWith};
-use serde_json::{Value, Map};
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::fs;
-
-/// Analyzes JavaScript code to extract state from vibe() calls
-pub struct JsAnalyzer {
-    base_path: PathBuf,
-    _module_cache: HashMap<PathBuf, Module>,
-    /// Memoizes resolved imports by (file, export name). Dedupes diamond imports
-    /// (without it, recursive resolution re-parses shared modules exponentially)
-    /// and breaks cycles (an in-progress entry is seeded `None`).
-    import_cache: HashMap<(PathBuf, String), Option<Value>>,
-}
-
-impl JsAnalyzer {
-    pub fn new(base_path: PathBuf) -> Self {
-        Self {
-            base_path,
-            _module_cache: HashMap::new(),
-            import_cache: HashMap::new(),
-        }
-    }
-
-    /// Extract state from a JavaScript/TypeScript script
-    pub fn extract_state(&mut self, script: &str) -> Option<Value> {
-        // eprintln!("[JsAnalyzer] extract_state called, script length: {}", script.len());
-        let module = self.parse_module(script)?;
-        // eprintln!("[JsAnalyzer] Module parsed");
-
-        // Build scope with import resolution
-        let mut scope_builder = ScopeBuilder::new(self.base_path.clone());
-        module.visit_with(&mut scope_builder);
-        // eprintln!("[JsAnalyzer] Found {} imports", scope_builder.imports.len());
-
-        // Resolve imports to actual Values (keyed by the LOCAL name used in code)
-        let mut resolved_imports: HashMap<String, Value> = HashMap::new();
-        for (local_name, (import_path, imported_name)) in scope_builder.imports.clone() {
-            if let Some(value) = self.resolve_import_value(&import_path, &imported_name) {
-                resolved_imports.insert(local_name, value);
-            }
-        }
-
-        // Find vibe() calls and resolve their arguments
-        let mut state_extractor = StateExtractor::new(scope_builder.bindings);
-        state_extractor.resolved_imports = resolved_imports;
-        module.visit_with(&mut state_extractor);
-
-        state_extractor.merged_state
-    }
-
-    /// Resolve an import and return the exported value (fully resolved).
-    /// `imported_name` is the EXPORT name to look up ("default" for a default
-    /// import). The imported module's OWN imports are resolved too, so a chain
-    /// like `import appState` → `export default { version: VERSION }` →
-    /// `import VERSION from './version.js'` resolves all the way down.
-    fn resolve_import_value(&mut self, import_path: &str, imported_name: &str) -> Option<Value> {
-        self.resolve_import_value_depth(import_path, imported_name, 0)
-    }
-
-    fn resolve_import_value_depth(
-        &mut self,
-        import_path: &str,
-        imported_name: &str,
-        depth: usize,
-    ) -> Option<Value> {
-        // Guard against pathological depth.
-        if depth > 16 {
-            return None;
-        }
-
-        let resolved_path = self.resolve_path(import_path)?;
-        let cache_key = (resolved_path.clone(), imported_name.to_string());
-        if let Some(cached) = self.import_cache.get(&cache_key) {
-            return cached.clone();
-        }
-        // Seed the in-progress entry so an import cycle resolves to None instead
-        // of recursing forever.
-        self.import_cache.insert(cache_key.clone(), None);
-
-        let result = self.resolve_export_from_file(&resolved_path, imported_name, depth);
-        self.import_cache.insert(cache_key, result.clone());
-        result
-    }
-
-    fn resolve_export_from_file(
-        &mut self,
-        resolved_path: &PathBuf,
-        imported_name: &str,
-        depth: usize,
-    ) -> Option<Value> {
-        let code = fs::read_to_string(resolved_path).ok()?;
-        let module = self.parse_module(&code)?;
-
-        // Build scope for the imported module.
-        let mut scope_builder = ScopeBuilder::new(resolved_path.parent()?.to_path_buf());
-        module.visit_with(&mut scope_builder);
-
-        // Recursively resolve THIS module's own imports so a property like
-        // `version: VERSION` (itself a default import) can be resolved. Import
-        // paths in this codebase are absolute (`/js/...`), resolved against the
-        // analyzer's fixed base, so no per-module base swap is needed.
-        let mut resolved_imports: HashMap<String, Value> = HashMap::new();
-        for (local_name, (path, name)) in scope_builder.imports.clone() {
-            if let Some(value) = self.resolve_import_value_depth(&path, &name, depth + 1) {
-                resolved_imports.insert(local_name, value);
-            }
-        }
-
-        // Find the requested export.
-        let mut export_finder =
-            ExportFinder::new(imported_name.to_string(), scope_builder.bindings.clone());
-        module.visit_with(&mut export_finder);
-
-        let expr = export_finder.found_export?;
-        let mut state_extractor = StateExtractor::new(scope_builder.bindings);
-        state_extractor.resolved_imports = resolved_imports;
-        state_extractor.resolve_expr(&expr)
-    }
-
-    /// Resolve import path relative to base_path
-    fn resolve_path(&self, import_path: &str) -> Option<PathBuf> {
-        // eprintln!("[JsAnalyzer] Resolving path: '{}' from base: '{:?}'", import_path, self.base_path);
-        let resolved = if import_path.starts_with('/') {
-            // Absolute path: treat as relative to base_path root
-            let clean_path = import_path.strip_prefix('/').unwrap_or(import_path);
-            let candidate = self.base_path.join(clean_path);
-            // eprintln!("[JsAnalyzer] Candidate absolute path: {:?}", candidate);
-            candidate
-        } else if import_path.starts_with("./") || import_path.starts_with("../") {
-            // Relative path
-            self.base_path.join(import_path)
-        } else {
-            // Neither absolute nor relative - treat as relative
-            self.base_path.join(import_path)
-        };
-
-        // Try with and without .js extension
-        if resolved.exists() {
-            // eprintln!("[JsAnalyzer] Path exists: {:?}", resolved);
-            Some(resolved)
-        } else {
-            // eprintln!("[JsAnalyzer] Path doesn't exist, trying with .js extension");
-            let with_js = resolved.with_extension("js");
-            if with_js.exists() {
-                // eprintln!("[JsAnalyzer] Path with .js exists: {:?}", with_js);
-                Some(with_js)
-            } else {
-                // eprintln!("[JsAnalyzer] Path not found: {:?}", resolved);
-                None
-            }
-        }
-    }
-
-    /// Parse JavaScript/TypeScript module. Uses a FRESH source map per call —
-    /// recursive import resolution parses many files, and a shared map would
-    /// accumulate byte positions until they overflow (`start <= end` panic).
-    fn parse_module(&self, code: &str) -> Option<Module> {
-        let source_map: Lrc<SourceMap> = Default::default();
-        let fm = source_map.new_source_file(
-            Lrc::new(FileName::Anon),
-            code.to_string(),
-        );
-
-        let syntax = Syntax::Es(EsSyntax {
-            jsx: false,
-            decorators: true,
-            ..Default::default()
-        });
-
-        let input = StringInput::new(
-            &fm.src,
-            fm.start_pos,
-            fm.end_pos,
-        );
-
-        let mut parser = Parser::new(
-            syntax,
-            input,
-            None,
-        );
-
-        parser.parse_module().ok()
-    }
-}
-
-/// Builds a scope of variable bindings and tracks imports
-struct ScopeBuilder {
-    bindings: HashMap<String, Expr>,
-    // local binding name -> (import path, imported export name; "default" for a
-    // default import, "*" for a namespace import)
-    imports: HashMap<String, (String, String)>,
-    _base_path: PathBuf,
-}
-
-impl ScopeBuilder {
-    fn new(base_path: PathBuf) -> Self {
-        Self {
-            bindings: HashMap::new(),
-            imports: HashMap::new(),
-            _base_path: base_path,
-        }
-    }
-}
-
-impl Visit for ScopeBuilder {
-    fn visit_import_decl(&mut self, import: &ImportDecl) {
-        let import_path = import.src.value.to_string();
-
-        for specifier in &import.specifiers {
-            match specifier {
-                // import { orig as local } from './file.js'
-                ImportSpecifier::Named(named) => {
-                    let imported = match &named.imported {
-                        Some(ModuleExportName::Ident(ident)) => ident.sym.to_string(),
-                        Some(ModuleExportName::Str(s)) => s.value.to_string(),
-                        None => named.local.sym.to_string(),
-                    };
-                    self.imports
-                        .insert(named.local.sym.to_string(), (import_path.clone(), imported));
-                }
-                // import name from './file.js' (default import)
-                ImportSpecifier::Default(default) => {
-                    self.imports.insert(
-                        default.local.sym.to_string(),
-                        (import_path.clone(), "default".to_string()),
-                    );
-                }
-                // import * as name from './file.js' (namespace import)
-                ImportSpecifier::Namespace(namespace) => {
-                    self.imports.insert(
-                        namespace.local.sym.to_string(),
-                        (import_path.clone(), "*".to_string()),
-                    );
-                }
-            }
-        }
-
-        import.visit_children_with(self);
-    }
-
-    fn visit_export_decl(&mut self, export: &ExportDecl) {
-        // Handle: export const name = value
-        match &export.decl {
-            Decl::Var(var_decl) => {
-                self.visit_var_decl(var_decl);
-            }
-            _ => {}
-        }
-        export.visit_children_with(self);
-    }
-
-    fn visit_var_decl(&mut self, decl: &VarDecl) {
-        for declarator in &decl.decls {
-            if let Pat::Ident(ident) = &declarator.name {
-                if let Some(init) = &declarator.init {
-                    self.bindings.insert(
-                        ident.id.sym.to_string(),
-                        (**init).clone(),
-                    );
-                }
-            }
-        }
-        decl.visit_children_with(self);
-    }
-}
-
-/// Finds exported bindings in a module
-struct ExportFinder {
-    target_name: String,
-    bindings: HashMap<String, Expr>,
-    found_export: Option<Expr>,
-}
-
-impl ExportFinder {
-    fn new(target_name: String, bindings: HashMap<String, Expr>) -> Self {
-        Self {
-            target_name,
-            bindings,
-            found_export: None,
-        }
-    }
-}
-
-impl Visit for ExportFinder {
-    // `export default <expr>` — matched when the consumer used a default import.
-    fn visit_export_default_expr(&mut self, export: &ExportDefaultExpr) {
-        if self.target_name == "default" {
-            self.found_export = Some((*export.expr).clone());
-        }
-    }
-
-    fn visit_export_decl(&mut self, export: &ExportDecl) {
-        match &export.decl {
-            Decl::Var(var_decl) => {
-                for declarator in &var_decl.decls {
-                    if let Pat::Ident(ident) = &declarator.name {
-                        if ident.id.sym.to_string() == self.target_name {
-                            if let Some(init) = &declarator.init {
-                                self.found_export = Some((**init).clone());
-                                return;
-                            }
-                        }
-                    }
-                }
-            }
-            _ => {}
-        }
-        export.visit_children_with(self);
-    }
-
-    fn visit_named_export(&mut self, export: &NamedExport) {
-        // Handle: export { name }
-        for specifier in &export.specifiers {
-            if let ExportSpecifier::Named(named) = specifier {
-                // Get the local name (what it's called in this file)
-                let local_name = if let ModuleExportName::Ident(ident) = &named.orig {
-                    ident.sym.to_string()
-                } else {
-                    continue;
-                };
-
-                // Get the export name (what it's called when imported)
-                let export_name = match &named.exported {
-                    Some(ModuleExportName::Ident(ident)) => ident.sym.to_string(),
-                    _ => local_name.clone(),
-                };
-
-                // Check if this is the export we're looking for
-                if export_name == self.target_name {
-                    // Look up the binding
-                    if let Some(binding) = self.bindings.get(&local_name) {
-                        self.found_export = Some(binding.clone());
-                        return;
-                    }
-                }
-            }
-        }
-        export.visit_children_with(self);
-    }
-}
-
-/// Extracts state from vibe()/state()/component() calls
-struct StateExtractor {
-    bindings: HashMap<String, Expr>,
-    resolved_imports: HashMap<String, Value>,
-    merged_state: Option<Value>,
-}
-
-impl StateExtractor {
-    fn new(bindings: HashMap<String, Expr>) -> Self {
-        Self {
-            bindings,
-            resolved_imports: HashMap::new(),
-            merged_state: None,
-        }
-    }
-
-    /// Resolve an expression to a JSON value
-    fn resolve_expr(&self, expr: &Expr) -> Option<Value> {
-        match expr {
-            // Object literal: { a: 1, b: 2 }
-            Expr::Object(obj) => self.resolve_object(obj),
-
-            // Array literal: [1, 2, 3]
-            Expr::Array(arr) => self.resolve_array(arr),
-
-            // String literal: "hello"
-            Expr::Lit(Lit::Str(s)) => Some(Value::String(s.value.to_string())),
-
-            // Number literal: 42
-            Expr::Lit(Lit::Num(n)) => {
-                serde_json::Number::from_f64(n.value)
-                    .map(Value::Number)
-            }
-
-            // Boolean literal: true/false
-            Expr::Lit(Lit::Bool(b)) => Some(Value::Bool(b.value)),
-
-            // Null literal
-            Expr::Lit(Lit::Null(_)) => Some(Value::Null),
-
-            // Identifier: resolve from imports first, then bindings
-            Expr::Ident(ident) => {
-                let name = ident.sym.to_string();
-
-                // Check resolved imports first (these are fully resolved Values)
-                if let Some(value) = self.resolved_imports.get(&name) {
-                    return Some(value.clone());
-                }
-
-                // Fall back to bindings (these are Exprs that need resolution)
-                self.bindings.get(&name)
-                    .and_then(|expr| self.resolve_expr(expr))
-            }
-
-            // Parenthesized expression: (expr)
-            Expr::Paren(paren) => self.resolve_expr(&paren.expr),
-
-            _ => None, // Can't statically resolve
-        }
-    }
-
-    /// Resolve object literal with spread support
-    /// Uses partial resolution: resolves what it can, skips what it can't
-    fn resolve_object(&self, obj: &ObjectLit) -> Option<Value> {
-        let mut result = Map::new();
-
-        for prop in &obj.props {
-            match prop {
-                // Regular property: a: 1
-                PropOrSpread::Prop(prop) => {
-                    if let Prop::KeyValue(kv) = &**prop {
-                        if let Some(key) = self.get_prop_key(&kv.key) {
-                            if let Some(value) = self.resolve_expr(&kv.value) {
-                                result.insert(key, value);
-                            }
-                            // Skip properties that can't be resolved
-                        }
-                    } else if let Prop::Shorthand(ident) = &**prop {
-                        // Shorthand: { a } where a is a variable
-                        let key = ident.sym.to_string();
-                        if let Some(expr) = self.bindings.get(&key) {
-                            if let Some(value) = self.resolve_expr(expr) {
-                                result.insert(key, value);
-                            }
-                        }
-                        // Skip if can't resolve
-                    }
-                }
-
-                // Spread: ...other
-                PropOrSpread::Spread(spread) => {
-                    // Resolve the spread expression
-                    if let Some(Value::Object(spread_obj)) = self.resolve_expr(&spread.expr) {
-                        // Merge spread properties
-                        for (k, v) in spread_obj {
-                            result.insert(k, v);
-                        }
-                    }
-                    // Skip spreads that can't be resolved
-                }
-            }
-        }
-
-        // Return partial object even if some properties couldn't be resolved
-        if result.is_empty() {
-            None
-        } else {
-            Some(Value::Object(result))
-        }
-    }
-
-    /// Resolve array literal
-    /// Uses partial resolution: includes elements that can be resolved, skips others
-    fn resolve_array(&self, arr: &ArrayLit) -> Option<Value> {
-        let mut result = Vec::new();
-
-        for elem in &arr.elems {
-            if let Some(elem) = elem {
-                match elem {
-                    // Regular element
-                    ExprOrSpread { spread: None, expr } => {
-                        if let Some(value) = self.resolve_expr(expr) {
-                            result.push(value);
-                        }
-                        // Skip elements that can't be resolved
-                    }
-                    // Spread element: ...arr
-                    ExprOrSpread { spread: Some(_), expr } => {
-                        if let Some(Value::Array(spread_arr)) = self.resolve_expr(expr) {
-                            result.extend(spread_arr);
-                        }
-                        // Skip spreads that can't be resolved
-                    }
-                }
-            }
-        }
-
-        // Return partial array even if some elements couldn't be resolved
-        if result.is_empty() {
-            None
-        } else {
-            Some(Value::Array(result))
-        }
-    }
-
-    /// Get string key from property name
-    fn get_prop_key(&self, key: &PropName) -> Option<String> {
-        match key {
-            PropName::Ident(ident) => Some(ident.sym.to_string()),
-            PropName::Str(s) => Some(s.value.to_string()),
-            _ => None,
-        }
-    }
-
-    /// Merge state from a vibe() call
-    fn merge_state(&mut self, state: Value) {
-        if let Value::Object(new_state) = state {
-            match &mut self.merged_state {
-                Some(Value::Object(existing)) => {
-                    for (k, v) in new_state {
-                        existing.insert(k, v);
-                    }
-                }
-                _ => {
-                    self.merged_state = Some(Value::Object(new_state));
-                }
-            }
-        }
-    }
-}
-
-impl Visit for StateExtractor {
-    fn visit_call_expr(&mut self, call: &CallExpr) {
-        // Check if this is a vibe() or state() call
-        if let Callee::Expr(expr) = &call.callee {
-            if let Expr::Ident(ident) = &**expr {
-                let name = ident.sym.to_string();
-                if name == "vibe" || name == "state" || name == "component" {
-                    // Get first argument (the state object)
-                    if let Some(arg) = call.args.first() {
-                        if let Some(state) = self.resolve_expr(&arg.expr) {
-                            self.merge_state(state);
-                        }
-                    }
-                }
-            }
-        }
-
-        call.visit_children_with(self);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn test_simple_object() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("."));
-        let script = r#"
-            vibe({ count: 0, name: "test" });
-        "#;
-
-        let state = analyzer.extract_state(script).unwrap();
-        assert_eq!(state, json!({ "count": 0, "name": "test" }));
-    }
-
-    #[test]
-    fn test_variable_reference() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("."));
-        let script = r#"
-            const items = [1, 2, 3];
-            vibe({ items });
-        "#;
-
-        let state = analyzer.extract_state(script).unwrap();
-        assert_eq!(state, json!({ "items": [1, 2, 3] }));
-    }
-
-    #[test]
-    fn test_spread_operator() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("."));
-        let script = r#"
-            const base = { a: 1, b: 2 };
-            vibe({ ...base, c: 3 });
-        "#;
-
-        let state = analyzer.extract_state(script).unwrap();
-        assert_eq!(state, json!({ "a": 1, "b": 2, "c": 3 }));
-    }
-
-    #[test]
-    fn test_nested_objects() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("."));
-        let script = r#"
-            const user = { name: "John", age: 30 };
-            vibe({ user, count: 0 });
-        "#;
-
-        let state = analyzer.extract_state(script).unwrap();
-        assert_eq!(state, json!({ "user": { "name": "John", "age": 30 }, "count": 0 }));
-    }
-
-    #[test]
-    fn test_array_spread() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("."));
-        let script = r#"
-            const base = [1, 2];
-            const items = [...base, 3, 4];
-            vibe({ items });
-        "#;
-
-        let state = analyzer.extract_state(script).unwrap();
-        assert_eq!(state, json!({ "items": [1, 2, 3, 4] }));
-    }
-
-    #[test]
-    fn test_import_resolution() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("/tmp"));
-        let script = r#"
-            import { data } from './test-import.js';
-            vibe({ ...data, c: 3 });
-        "#;
-
-        let state = analyzer.extract_state(script).unwrap();
-        assert_eq!(state["a"].as_f64().unwrap(), 1.0);
-        assert_eq!(state["b"].as_f64().unwrap(), 2.0);
-        assert_eq!(state["c"].as_f64().unwrap(), 3.0);
-    }
-
-    #[test]
-    fn test_component_called_with_variable() {
-        // component(state) — the whole argument is a variable bound to an object
-        // literal above (BrawlerDetailContent does exactly this). The extractor
-        // must resolve the variable; otherwise the component wrapper is never
-        // tagged and its `this.` conditionals can't resolve at runtime.
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("."));
-        let script = r#"
-            const state = {
-              currentCharacter: null,
-              currentSlots: [],
-              currentLastTickEnd: 0,
-            };
-            setupCharacter(state);
-            const id = component(state);
-        "#;
-
-        let state = analyzer.extract_state(script).expect("state should be extracted");
-        assert!(state.get("currentCharacter").is_some(), "got: {state}");
-        assert_eq!(state["currentLastTickEnd"].as_f64().unwrap(), 0.0);
-    }
-
-    #[test]
-    fn test_component_var_amid_realistic_script() {
-        // Mirrors BrawlerDetailContent's script shape: top-level imports, a
-        // dynamic import().then(), an empty `catch {}`, optional chaining, and
-        // `component(state)`. A parse failure on any of these makes extract_state
-        // return None and the component goes untagged.
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("."));
-        let script = r#"
-            import CHARACTERS from '/js/constants/CHARACTERS.js';
-            import { buildEquipmentSlots, unequip } from '/js/equipment.js';
-
-            const backParam = new URLSearchParams(location.search).get('back') || '';
-            const state = {
-              currentCharacter: null,
-              currentSlots: [],
-              currentLastTickEnd: 0,
-              backUrl: backParam.startsWith('/') ? backParam : '',
-            };
-
-            const setupCharacter = (target) => {
-              const ref = $.characters?.[0];
-              try { ref.foo(); } catch {}
-              target.currentCharacter = ref;
-            };
-
-            setupCharacter(state);
-            const id = component(state);
-
-            import('/js/dnd.js').then(({ default: dnd }) => { dnd.init(); });
-        "#;
-
-        let state = analyzer.extract_state(script).expect("state should be extracted");
-        assert!(state.get("currentCharacter").is_some(), "got: {state}");
-    }
-
-    #[test]
-    fn test_absolute_path_import() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("/tmp"));
-        let script = r#"
-            import { menuState } from '/test-data.js';
-            vibe({ ...menuState, extra: "value" });
-        "#;
-
-        let state = analyzer.extract_state(script);
-        assert!(state.is_some(), "State should be extracted");
-        let state = state.unwrap();
-        assert!(state["menuSections"].is_array(), "menuSections should be an array");
-        assert_eq!(state["other"].as_str().unwrap(), "value");
-        assert_eq!(state["extra"].as_str().unwrap(), "value");
-    }
-
-    #[test]
-    fn resolves_default_import_chain() {
-        // Two nested DEFAULT imports, mirroring boot.js → app.js → version.js:
-        // `import appState` → `export default { version: VERSION }` → `import VERSION`.
-        let dir = std::env::temp_dir().join("vibe_default_import_chain_test");
-        let _ = fs::remove_dir_all(&dir);
-        fs::create_dir_all(&dir).unwrap();
-        fs::write(dir.join("version.js"), "export default '0.1.5';").unwrap();
-        fs::write(
-            dir.join("app.js"),
-            "import VERSION from '/version.js';\nexport default { version: VERSION, coins: 400 };",
-        )
-        .unwrap();
-
-        let mut analyzer = JsAnalyzer::new(dir.clone());
-        let state = analyzer
-            .extract_state("import appState from '/app.js';\nvibe({ ...appState });")
-            .unwrap();
-
-        assert_eq!(state["version"], "0.1.5");
-        assert_eq!(state["coins"].as_f64(), Some(400.0));
-
-        let _ = fs::remove_dir_all(&dir);
-    }
-}