testeranto 0.342.1 → 0.343.0

package/dist/golang/main.go

@@ -8,8 +8,10 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"os/signal"
 	"path/filepath"
 	"strings"
+	"syscall"
 	
 	// frameworkconverters package is not available in this context
 	// We'll handle native detection directly without the converters
@@ -109,8 +111,18 @@ func main() {
 	testName := args[3]
 	entryPoints := args[4:]
 
-	fmt.Printf("Test name: %s\n", testName)
-	fmt.Printf("Entry points: %v\n", entryPoints)
+	// Check if we're in dev mode
+	mode := os.Getenv("MODE")
+	isDevMode := mode == "dev"
+
+	fmt.Printf("[Go Builder] Test name: %s\n", testName)
+	fmt.Printf("[Go Builder] Entry points: %v\n", entryPoints)
+	fmt.Printf("[Go Builder] Mode: %s\n", func() string {
+		if isDevMode {
+			return "dev"
+		}
+		return "once"
+	}())
 
 	if len(entryPoints) == 0 {
 		fmt.Fprintln(os.Stderr, "❌ No entry points provided")
@@ -363,6 +375,96 @@ func main() {
 	fmt.Printf("\n✅ Created inputFiles.json at %s with %d tests\n", inputFilesPath, len(allTestsInfo))
 
 	fmt.Println("\n🎉 Go builder completed successfully")
+	
+// produceOutputArtifacts copies output files to the output directory
+func produceOutputArtifacts(projectConfigPath, configKey string) {
+	fmt.Printf("[Go Builder] Producing output artifacts for config %s\n", configKey)
+	
+	// Load project config
+	configFile, err := os.ReadFile(projectConfigPath)
+	if err != nil {
+		fmt.Printf("[Go Builder] Error loading project config: %v\n", err)
+		return
+	}
+	
+	var projectConfig map[string]interface{}
+	if err := json.Unmarshal(configFile, &projectConfig); err != nil {
+		fmt.Printf("[Go Builder] Error parsing project config: %v\n", err)
+		return
+	}
+	
+	runtimes, ok := projectConfig["runtimes"].(map[string]interface{})
+	if !ok {
+		fmt.Printf("[Go Builder] No runtimes found in config\n")
+		return
+	}
+	
+	runtimeConfig, ok := runtimes[configKey].(map[string]interface{})
+	if !ok {
+		fmt.Printf("[Go Builder] No runtime config found for %s\n", configKey)
+		return
+	}
+	
+	outputsInterface, ok := runtimeConfig["outputs"].([]interface{})
+	if !ok || outputsInterface == nil {
+		fmt.Printf("[Go Builder] No outputs defined for %s\n", configKey)
+		return
+	}
+	
+	fmt.Printf("[Go Builder] Processing %d output artifacts\n", len(outputsInterface))
+	
+	// Create output directory
+	outputDir := filepath.Join("testeranto", "outputs", configKey)
+	if err := os.MkdirAll(outputDir, 0755); err != nil {
+		fmt.Printf("[Go Builder] Error creating output directory: %v\n", err)
+		return
+	}
+	
+	for _, outputInterface := range outputsInterface {
+		entrypoint, ok := outputInterface.(string)
+		if !ok {
+			continue
+		}
+		
+		sourcePath := entrypoint
+		fileName := filepath.Base(entrypoint)
+		destPath := filepath.Join(outputDir, fileName)
+		
+		fmt.Printf("[Go Builder] Copying %s to %s\n", sourcePath, destPath)
+		
+		// Copy file
+		input, err := os.ReadFile(sourcePath)
+		if err != nil {
+			fmt.Printf("[Go Builder] Failed to read source file %s: %v\n", sourcePath, err)
+			continue
+		}
+		
+		if err := os.WriteFile(destPath, input, 0644); err != nil {
+			fmt.Printf("[Go Builder] Failed to write destination file %s: %v\n", destPath, err)
+			continue
+		}
+		
+		fmt.Printf("[Go Builder] ✅ Copied %s\n", fileName)
+	}
+	
+	fmt.Printf("[Go Builder] Finished producing output artifacts\n")
+}
+
+	// In dev mode, keep the process alive
+	if isDevMode {
+		fmt.Println("[Go Builder] Dev mode active - process will stay running")
+		
+		// Set up signal handling
+		sigChan := make(chan os.Signal, 1)
+		signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
+		
+		// Keep process alive until signal received
+		select {
+		case sig := <-sigChan:
+			fmt.Printf("[Go Builder] Received signal %v - producing output artifacts\n", sig)
+			produceOutputArtifacts(args[1], testName)
+		}
+	}
 }
 
 func getCurrentDir() string {

package/dist/java/main.java

@@ -25,9 +25,14 @@ public class java_runtime {
         String testName = args[2];
         String[] entryPoints = Arrays.copyOfRange(args, 3, args.length);
         
-        System.out.println("Java config path: " + javaConfigPath);
-        System.out.println("Test name: " + testName);
-        System.out.println("Entry points: " + Arrays.toString(entryPoints));
+        // Check if we're in dev mode
+        String mode = System.getenv("MODE");
+        boolean isDevMode = "dev".equals(mode);
+        
+        System.out.println("[Java Builder] Java config path: " + javaConfigPath);
+        System.out.println("[Java Builder] Test name: " + testName);
+        System.out.println("[Java Builder] Entry points: " + Arrays.toString(entryPoints));
+        System.out.println("[Java Builder] Mode: " + (isDevMode ? "dev" : "once"));
         
         // Load Java config file
         JSONObject javaConfig = loadJavaConfig(Paths.get(javaConfigPath));
@@ -151,6 +156,28 @@ public class java_runtime {
         System.out.println("\n✅ Created inputFiles.json at " + inputFilesPath + " with " + allTestsInfo.length() + " tests");
         
         System.out.println("\n🎉 Java builder completed successfully");
+        
+        // In dev mode, keep the process alive
+        if (isDevMode) {
+            System.out.println("[Java Builder] Dev mode active - process will stay running");
+            
+            // Add shutdown hook for SIGTERM
+            Runtime.getRuntime().addShutdownHook(new Thread() {
+                public void run() {
+                    System.out.println("[Java Builder] Received shutdown signal - shutting down");
+                }
+            });
+            
+            // Keep process alive
+            while (true) {
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
+        }
     }
     
     private static void createJarFile(String testPath, Path jarPath, JSONObject javaConfig, 

package/dist/python/python.py

@@ -236,10 +236,15 @@ def main():
     test_name = sys.argv[3]
     entry_points = sys.argv[4:]
     
+    # Check if we're in dev mode
+    import os
+    is_dev_mode = os.environ.get('MODE') == 'dev'
+    
     print(f"[Python Builder] Project config: {project_config_file_path}")
     print(f"[Python Builder] Python config: {python_config_file_path}")
     print(f"[Python Builder] Test name: {test_name}")
     print(f"[Python Builder] Entry points: {entry_points}")
+    print(f"[Python Builder] Mode: {'dev' if is_dev_mode else 'once'}")
     
     # Create a dictionary to store all tests' information
     all_tests_info = {}
@@ -386,6 +391,101 @@ exec(code, {{'__name__': '__main__', '__file__': r'{original_test_abs}'}})
     print(f"[Python Builder] Wrote inputFiles.json for {len(all_tests_info)} tests to {input_files_path}")
     
     print("[Python Builder] Python builder completed")
+    
+def produce_output_artifacts(project_config_path: str, config_key: str):
+    """Produce output artifacts before shutting down."""
+    print(f"[Python Builder] Producing output artifacts for config {config_key}")
+    
+    # Load project config
+    import json
+    try:
+        with open(project_config_path, 'r', encoding='utf-8') as f:
+            project_config = json.load(f)
+    except Exception as e:
+        print(f"[Python Builder] Error loading project config: {e}")
+        return
+    
+    runtime_config = project_config.get('runtimes', {}).get(config_key)
+    if not runtime_config:
+        print(f"[Python Builder] No runtime config found for {config_key}")
+        return
+    
+    outputs = runtime_config.get('outputs', [])
+    if not outputs:
+        print(f"[Python Builder] No outputs defined for {config_key}")
+        return
+    
+    print(f"[Python Builder] Processing {len(outputs)} output artifacts")
+    
+    # Create output directory
+    output_dir = f"testeranto/outputs/{config_key}"
+    os.makedirs(output_dir, exist_ok=True)
+    
+    for entrypoint in outputs:
+        try:
+            source_path = entrypoint
+            import shutil
+            file_name = os.path.basename(entrypoint)
+            dest_path = os.path.join(output_dir, file_name)
+            
+            print(f"[Python Builder] Copying {source_path} to {dest_path}")
+            
+            # Copy file
+            shutil.copy2(source_path, dest_path)
+            
+            print(f"[Python Builder] ✅ Copied {file_name}")
+        except Exception as e:
+            print(f"[Python Builder] Failed to process output artifact {entrypoint}: {e}")
+    
+    print(f"[Python Builder] Finished producing output artifacts")
+
+    # In dev mode, keep the process alive
+    if is_dev_mode:
+        print("[Python Builder] Dev mode active - process will stay running")
+        import signal
+        import time
+        
+        def handle_sigterm(signum, frame):
+            print("[Python Builder] Received SIGTERM - producing output artifacts")
+            produce_output_artifacts(project_config_file_path, test_name)
+            sys.exit(0)
+        
+        def handle_sigint(signum, frame):
+            print("[Python Builder] Received SIGINT - producing output artifacts")
+            produce_output_artifacts(project_config_file_path, test_name)
+            sys.exit(0)
+        
+        signal.signal(signal.SIGTERM, handle_sigterm)
+        signal.signal(signal.SIGINT, handle_sigint)
+        
+        # Keep process alive
+        while True:
+            time.sleep(1)
+    
+    # In dev mode, keep the process alive to watch for changes
+    # For now, we'll just keep the process running
+    # In a more complete implementation, we would watch for file changes
+    if is_dev_mode:
+        print("[Python Builder] Dev mode: keeping process alive...")
+        # Keep the process alive
+        # In a real implementation, we would watch for file changes here
+        # For now, just sleep indefinitely until SIGTERM
+        import signal
+        import time
+        
+        # Signal handler for SIGTERM to produce output artifacts
+        def sigterm_handler(signum, frame):
+            print("[Python Builder] Received SIGTERM - producing output artifacts")
+            # In a real implementation, we would produce output artifacts here
+            # For now, just exit
+            sys.exit(0)
+        
+        signal.signal(signal.SIGTERM, sigterm_handler)
+        signal.signal(signal.SIGINT, sigterm_handler)
+        
+        # Keep alive
+        while True:
+            time.sleep(1)
 
 if __name__ == "__main__":
     main()

package/dist/ruby/ruby.rb

@@ -17,23 +17,32 @@ ruby_config_file_path = ARGV[1]
 test_name = ARGV[2]
 entry_points = ARGV[3..-1]
 
+# Check if we're in dev mode
+is_dev_mode = ENV['MODE'] == 'dev'
+
+puts "[Ruby Builder] Project config: #{project_config_file_path}"
+puts "[Ruby Builder] Ruby config: #{ruby_config_file_path}"
+puts "[Ruby Builder] Test name: #{test_name}"
+puts "[Ruby Builder] Entry points: #{entry_points.join(', ')}"
+puts "[Ruby Builder] Mode: #{is_dev_mode ? 'dev' : 'once'}"
+
 # Load and parse configuration if needed
 begin
   if File.exist?(project_config_file_path)
     project_config = JSON.parse(File.read(project_config_file_path))
-    puts "Loaded project config"
+    puts "[Ruby Builder] Loaded project config"
   end
 rescue => e
-  puts "Warning: Could not parse project config: #{e.message}"
+  puts "[Ruby Builder] Warning: Could not parse project config: #{e.message}"
 end
 
 begin
   if File.exist?(ruby_config_file_path)
     ruby_config = JSON.parse(File.read(ruby_config_file_path))
-    puts "Loaded Ruby config"
+    puts "[Ruby Builder] Loaded Ruby config"
   end
 rescue => e
-  puts "Warning: Could not parse Ruby config: #{e.message}"
+  puts "[Ruby Builder] Warning: Could not parse Ruby config: #{e.message}"
 end
 
 # Delegate to native detection
@@ -48,4 +57,25 @@ end
 
 # detector.run
 
-puts "Ruby builder completed successfully"
+puts "[Ruby Builder] Ruby builder completed successfully"
+
+# In dev mode, keep the process alive
+if is_dev_mode
+  puts "[Ruby Builder] Dev mode active - process will stay running"
+  
+  # Signal handler for SIGTERM
+  Signal.trap('TERM') do
+    puts "[Ruby Builder] Received SIGTERM - shutting down"
+    exit 0
+  end
+  
+  Signal.trap('INT') do
+    puts "[Ruby Builder] Received SIGINT - shutting down"
+    exit 0
+  end
+  
+  # Keep process alive
+  loop do
+    sleep 1
+  end
+end

package/dist/rust/main.rs

@@ -27,8 +27,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let config_key = &args[3];
     let entry_points = &args[4..];
     
-    println!("Config key: {}", config_key);
-    println!("Entry points: {:?}", entry_points);
+    // Check if we're in dev mode
+    let mode = std::env::var("MODE").unwrap_or_else(|_| "once".to_string());
+    let is_dev_mode = mode == "dev";
+    
+    println!("[Rust Builder] Config key: {}", config_key);
+    println!("[Rust Builder] Entry points: {:?}", entry_points);
+    println!("[Rust Builder] Mode: {}", if is_dev_mode { "dev" } else { "once" });
     
     if entry_points.is_empty() {
         eprintln!("❌ No entry points provided");
@@ -335,6 +340,113 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("\n✅ Created inputFiles.json at {:?} with {} tests", input_files_path, all_tests_info.len());
     
     println!("\n🎉 Rust builder completed successfully");
+    
+fn produce_output_artifacts(project_config_path: &str, config_key: &str) {
+    println!("[Rust Builder] Producing output artifacts for config {}", config_key);
+    
+    // Load project config
+    let config_content = match std::fs::read_to_string(project_config_path) {
+        Ok(content) => content,
+        Err(e) => {
+            println!("[Rust Builder] Error loading project config: {}", e);
+            return;
+        }
+    };
+    
+    let project_config: serde_json::Value = match serde_json::from_str(&config_content) {
+        Ok(config) => config,
+        Err(e) => {
+            println!("[Rust Builder] Error parsing project config: {}", e);
+            return;
+        }
+    };
+    
+    let runtimes = match project_config.get("runtimes") {
+        Some(r) => r,
+        None => {
+            println!("[Rust Builder] No runtimes found in config");
+            return;
+        }
+    };
+    
+    let runtime_config = match runtimes.get(config_key) {
+        Some(rc) => rc,
+        None => {
+            println!("[Rust Builder] No runtime config found for {}", config_key);
+            return;
+        }
+    };
+    
+    let outputs = match runtime_config.get("outputs") {
+        Some(o) => o.as_array(),
+        None => {
+            println!("[Rust Builder] No outputs defined for {}", config_key);
+            return;
+        }
+    };
+    
+    let outputs = match outputs {
+        Some(o) => o,
+        None => {
+            println!("[Rust Builder] Outputs is not an array");
+            return;
+        }
+    };
+    
+    println!("[Rust Builder] Processing {} output artifacts", outputs.len());
+    
+    // Create output directory
+    let output_dir = format!("testeranto/outputs/{}", config_key);
+    if let Err(e) = std::fs::create_dir_all(&output_dir) {
+        println!("[Rust Builder] Error creating output directory: {}", e);
+        return;
+    }
+    
+    for output in outputs {
+        let entrypoint = match output.as_str() {
+            Some(s) => s,
+            None => continue,
+        };
+        
+        let source_path = entrypoint;
+        let file_name = match std::path::Path::new(entrypoint).file_name() {
+            Some(name) => name.to_string_lossy().to_string(),
+            None => continue,
+        };
+        
+        let dest_path = format!("{}/{}", output_dir, file_name);
+        
+        println!("[Rust Builder] Copying {} to {}", source_path, dest_path);
+        
+        // Copy file
+        if let Err(e) = std::fs::copy(source_path, &dest_path) {
+            println!("[Rust Builder] Failed to copy {}: {}", source_path, e);
+            continue;
+        }
+        
+        println!("[Rust Builder] ✅ Copied {}", file_name);
+    }
+    
+    println!("[Rust Builder] Finished producing output artifacts");
+}
+
+    // In dev mode, keep the process alive
+    if is_dev_mode {
+        println!("[Rust Builder] Dev mode active - process will stay running");
+        
+        // Set up signal handlers
+        ctrlc::set_handler(move || {
+            println!("[Rust Builder] Received SIGINT - producing output artifacts");
+            produce_output_artifacts(&_project_config_file_path, &config_key);
+            std::process::exit(0);
+        }).expect("Error setting Ctrl-C handler");
+        
+        // Simple approach: sleep until interrupted
+        loop {
+            std::thread::sleep(std::time::Duration::from_secs(1));
+        }
+    }
+    
     Ok(())
 }
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "testeranto",
   "displayName": "Testeranto",
   "description": "the AI powered test framework for polyglot projects",
-  "version": "0.342.1",
+  "version": "0.343.0",
   "engines": {
     "node": ">=20.19.0",
     "vscode": "^1.60.0",
@@ -201,6 +201,11 @@
     "ATDD"
   ],
   "exports": {
+    "./src/vscode/defaultViews/index.ts": {
+      "import": "./src/vscode/defaultViews/index.ts",
+      "require": "./src/vscode/defaultViews/index.ts",
+      "types": "./src/vscode/defaultViews/index.ts"
+    },
     "./src/*": {
       "import": "./src/*"
     },
@@ -312,7 +317,9 @@
       "import": "./src/views/index.ts",
       "require": "./src/views/index.ts"
     },
-    "./src/**/*": "./src/**/*.ts"
+    "./src/*/*": "./src/*/*.ts",
+    "./src/*/*/*": "./src/*/*/*.ts",
+    "./src/*/*/*/*": "./src/*/*/*/*.ts"
   },
   "peerDependencies": {
     "@types/react": "18.2.0",
@@ -370,9 +377,7 @@
     "@types/node-static": "^0.7.11",
     "@types/xmldom": "^0.1.34",
     "@ungap/structured-clone": "^1.3.0",
-    "@xterm/addon-fit": "^0.10.0",
     "ansi-colors": "^4.1.3",
-    "axios": "^1.11.0",
     "babel-loader": "^8.2.5",
     "bootstrap": "^5.3.7",
     "bootstrap-icons": "^1.13.1",
@@ -394,47 +399,36 @@
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-react": "^7.31.11",
     "eslint-plugin-react-hooks": "^5.1.0",
-    "express": "^4.21.2",
-    "fast-xml-parser": "^5.2.5",
-    "file-saver": "^2.0.5",
     "fs-extra": "^11.2.0",
     "fs.promises.exists": "^1.1.4",
     "glob": "^10.3.10",
     "graphology": "^0.26.0",
     "gray-matter": "^4.0.3",
-    "jiti": "*",
     "js-yaml": "^4.1.0",
     "license-checker": "^25.0.1",
     "mdast-util-frontmatter": "^2.0.1",
     "micromark": "^4.0.2",
     "micromark-extension-frontmatter": "^2.0.0",
     "micromark-extension-gfm-table": "^2.1.1",
-    "monaco-editor": "^0.45.0",
     "node-pty": "^1.0.0",
     "node-static": "^0.7.11",
     "puppeteer": "^24.4.0",
     "puppeteer-core": "24.4.0",
-    "queue": "^7.0.0",
     "react": "^19.2.4",
     "react-bootstrap": "^2.10.9",
     "react-dom": "^19.2.4",
     "react-router-dom": "^7.7.0",
     "react-test-renderer": "^19.2.0",
     "sass": "^1.90.0",
-    "ssml-check": "^0.4.6",
     "tsc-prog": "^2.3.0",
     "tsx": "^4.21.0",
-    "type-fest": "^4.41.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.29.1",
     "url": "^0.11.4",
     "uuid": "^10.0.0",
     "validate-with-xmllint": "^1.2.1",
     "ws": "^8.18.3",
-    "xmldom": "^0.6.0",
-    "xterm": "^5.3.0",
-    "xterm-addon-fit": "^0.8.0",
-    "xterm-react": "^1.0.0"
+    "xmldom": "^0.6.0"
   },
   "optionalDependencies": {
     "@esbuild/darwin-arm64": "^0.27.2",
@@ -445,4 +439,4 @@
     "@esbuild/win32-x64": "^0.27.2",
     "esbuild": "0.27.3"
   }
-}
+}

package/src/lib/kafe/pom.xml

@@ -7,7 +7,7 @@
     
     <groupId>com.testeranto</groupId>
     <artifactId>testeranto.kafe</artifactId>
-    <version>0.4.0</version>
+    <version>0.5.0</version>
     <packaging>jar</packaging>
     
     <name>Kafe - Java Implementation of Testeranto</name>