@ape-egg/vibe 1.3.2 → 1.6.1

package/compiler/src/compiler/js_analyzer.rs

@@ -0,0 +1,572 @@
+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 {
+    source_map: Lrc<SourceMap>,
+    base_path: PathBuf,
+    _module_cache: HashMap<PathBuf, Module>,
+}
+
+impl JsAnalyzer {
+    pub fn new(base_path: PathBuf) -> Self {
+        Self {
+            source_map: Lrc::new(SourceMap::default()),
+            base_path,
+            _module_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
+        let mut resolved_imports: HashMap<String, Value> = HashMap::new();
+        for (import_name, import_path) in &scope_builder.imports {
+            if let Some(value) = self.resolve_import_value(&import_path, import_name) {
+                resolved_imports.insert(import_name.clone(), 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)
+    fn resolve_import_value(&mut self, import_path: &str, import_name: &str) -> Option<Value> {
+        // eprintln!("[JsAnalyzer] Resolving import: '{}' name: '{}'", import_path, import_name);
+        // Resolve relative path
+        let resolved_path = self.resolve_path(import_path)?;
+        // eprintln!("[JsAnalyzer] Resolved to: {:?}", resolved_path);
+
+        // Read and parse the module
+        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);
+
+        // Find the exported binding
+        let mut export_finder = ExportFinder::new(
+            import_name.to_string(),
+            scope_builder.bindings.clone(),
+        );
+        module.visit_with(&mut export_finder);
+
+        // Resolve the exported expression with the file's bindings
+        if let Some(expr) = export_finder.found_export {
+            let state_extractor = StateExtractor::new(scope_builder.bindings);
+            return state_extractor.resolve_expr(&expr);
+        }
+
+        None
+    }
+
+    /// 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
+    fn parse_module(&self, code: &str) -> Option<Module> {
+        let fm = self.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>,
+    imports: HashMap<String, String>, // import_name -> import_path
+    _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 { name } from './file.js'
+                ImportSpecifier::Named(named) => {
+                    let _import_name = match &named.imported {
+                        Some(ModuleExportName::Ident(ident)) => ident.sym.to_string(),
+                        _ => named.local.sym.to_string(),
+                    };
+                    self.imports.insert(named.local.sym.to_string(), import_path.clone());
+                }
+                // import name from './file.js' (default import)
+                ImportSpecifier::Default(default) => {
+                    self.imports.insert(default.local.sym.to_string(), import_path.clone());
+                }
+                // import * as name from './file.js'
+                ImportSpecifier::Namespace(namespace) => {
+                    self.imports.insert(namespace.local.sym.to_string(), import_path.clone());
+                }
+            }
+        }
+
+        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 {
+    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_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");
+    }
+}