testeranto 0.221.6 → 0.222.0

package/Gemfile

@@ -1,18 +1,3 @@
-source 'https://rubygems.org'
-
-gem 'rubeno', '0.0.5'
-
-# Add any required gems here
-# For now, we'll keep it minimal
-gem 'json', '~> 2.6'
-source 'https://rubygems.org'
-
-# Add any required gems here
-# For now, we'll keep it minimal
 gem 'json', '~> 2.6'
 source 'https://rubygems.org'
 
-# Add any required gems here
-# For now, we'll keep it minimal
-gem 'json', '~> 2.6'
-

package/README.md

@@ -9,15 +9,26 @@ In more conrete terms, testeranto is
 - a VS code extension
 - integrates static tests, unit tests, integration tests and source code into focused Aider sessions.
 - turns github issues, BDD specs and markdown documentation into packaged artifacts and human readable test reports.
-- a library of code split across 7 packages
 
-1) testeranto (the server) npm - https://www.npmjs.com/package/testeranto
+- a library of code split across 7 languages and 2 purposes
+
+## the server
+
+testeranto.ts - the server 
+testeranto.rb
+testeranto.py
+testeranto.golang
+testeranto.java
+testeranto.rust
+
+## libraries
+
 2) tiposkripto (ts) npm
 3) rusto  (rust) cargo
 4) pitono (python) pypi
 5) golingvu (go) TBD
 6) kafe (java) TBD
-7) rubeno (ruby ) rubygems - https://rubygems.org/gems/rubeno
+7) rubeno (ruby ) rubygems 
 
 ## Philosophy
 

package/bundle.js

@@ -54,7 +54,6 @@ try {
 
 // Copy media files for webview
 
-
 const mediaDir = 'media';
 const distMediaDir = 'dist/vscode/media';
 
@@ -74,3 +73,19 @@ for (const file of mediaFiles) {
     console.warn(`Media file not found: ${src}`);
   }
 }
+
+// Copy Ruby artifact to dist/ruby folder
+const rubySrcPath = 'src/server/runtimes/ruby/ruby.rb';
+const rubyDistDir = 'dist/ruby';
+const rubyDestPath = path.join(rubyDistDir, 'ruby.rb');
+
+if (!fs.existsSync(rubyDistDir)) {
+  fs.mkdirSync(rubyDistDir, { recursive: true });
+}
+
+if (fs.existsSync(rubySrcPath)) {
+  fs.copyFileSync(rubySrcPath, rubyDestPath);
+  console.log(`Copied Ruby artifact from ${rubySrcPath} to ${rubyDestPath}`);
+} else {
+  console.warn(`Ruby source file not found: ${rubySrcPath}`);
+}

package/dist/prebuild/testeranto.mjs

@@ -83,6 +83,7 @@ var nodeDockerComposeFile = (config, container_name, projectConfigPath, nodeConf
     environment: {
       NODE_ENV: "production",
       ENV: "node",
+      // <- important
       ...config.env
     },
     working_dir: "/workspace",
@@ -149,13 +150,13 @@ var rubyDockerComposeFile = (config, container_name, projectConfigPath, rubyConf
       `${process.cwd()}/src:/workspace/src`,
       `${process.cwd()}/example:/workspace/example`,
       `${process.cwd()}/dist:/workspace/dist`,
-      `${process.cwd()}/testeranto:/workspace/testeranto`
+      `${process.cwd()}/../../testeranto:/workspace/testeranto`
     ],
     command: rubyBuildCommand(projectConfigPath, rubyConfigPath, testName)
   };
 };
 var rubyBuildCommand = (projectConfigPath, rubyConfigPath, testName) => {
-  return `bundle exec rubeno /workspace/testeranto/testeranto.ts /workspace/${rubyConfigPath} ${testName}`;
+  return `ruby /workspace/testeranto/src/server/runtimes/ruby/ruby.rb /workspace/${rubyConfigPath} ${testName}`;
 };
 var rubyBddCommand = (fpath) => {
   const jsonStr = JSON.stringify({ ports: [1111] });
@@ -515,8 +516,9 @@ var Server_HTTP = class extends Server_Base {
   async start() {
     console.log(`[Server_HTTP] start()`);
     super.start();
+    const port = 3e3;
     return new Promise((resolve) => {
-      this.httpServer.on("listening", () => {
+      this.httpServer.listen(port, () => {
         const addr = this.httpServer.address();
         console.log(`[HTTP] HTTP server is now listening on ${addr}`);
         resolve();
@@ -1064,26 +1066,26 @@ ${x}
     `;
   }
   getUpCommand() {
-    return `docker compose up -d`;
+    return `docker compose -f "testeranto/docker-compose.yml" up -d`;
   }
   getDownCommand() {
-    return `docker compose down -v --remove-orphans`;
+    return `docker compose -f "testeranto/docker-compose.yml" down -v --remove-orphans`;
   }
   getPsCommand() {
-    return `docker compose ps`;
+    return `docker compose -f "testeranto/docker-compose.yml" ps`;
   }
   getLogsCommand(serviceName, tail = 100) {
-    const base = `docker compose logs --no-color --tail=${tail}`;
+    const base = `docker compose -f "testeranto/docker-compose.yml" logs --no-color --tail=${tail}`;
     return serviceName ? `${base} ${serviceName}` : base;
   }
   getConfigServicesCommand() {
-    return `docker compose config --services`;
+    return `docker compose -f "testeranto/docker-compose.yml" config --services`;
   }
   getBuildCommand() {
-    return `docker compose build`;
+    return `docker compose -f "testeranto/docker-compose.yml" build`;
   }
   getStartCommand() {
-    return `docker compose start`;
+    return `docker compose -f "testeranto/docker-compose.yml" start`;
   }
   // private async waitForContainerExists(serviceName: string, maxAttempts: number = 30, delayMs: number = 1000): Promise<boolean> {
   //   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -1138,7 +1140,8 @@ ${x}
     console.log(`[Server_Docker] Starting log capture for ${serviceName} to ${logFilePath}`);
     const logStream = fs2.createWriteStream(logFilePath, { flags: "a" });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    logStream.write(`=== Log started at ${timestamp} for service ${serviceName} ===
+    logStream.write(`
+=== Log started at ${timestamp} for service ${serviceName} ===
 
 `);
     const child = spawn("bash", ["-c", logScript], {
@@ -1220,8 +1223,17 @@ ${x}
   }
   async start() {
     console.log(`[Server_Docker] start()`);
-    super.start();
-    await this.setupDockerCompose();
+    try {
+      await super.start();
+    } catch (error) {
+      console.error(`[Server_Docker] Error in super.start():`, error);
+    }
+    this.writeConfigForExtension();
+    try {
+      await this.setupDockerCompose();
+    } catch (error) {
+      console.error(`[Server_Docker] Error in setupDockerCompose():`, error);
+    }
     const baseReportsDir = path2.join(process.cwd(), "testeranto", "reports");
     try {
       fs2.mkdirSync(baseReportsDir, { recursive: true });
@@ -1231,20 +1243,31 @@ ${x}
     }
     console.log(`[Server_Docker] Dropping everything...`);
     try {
-      const downCmd = `docker compose -f "testeranto/docker-compose.yml" down -v --remove-orphans`;
+      const downCmd = this.getDownCommand();
       console.log(`[Server_Docker] Running: ${downCmd}`);
       await this.spawnPromise(downCmd);
       console.log(`[Server_Docker] Docker compose down completed`);
     } catch (error) {
       console.log(`[Server_Docker] Docker compose down noted: ${error.message}`);
     }
+    console.log(`[Server_Docker] Rebuilding all services...`);
+    try {
+      const buildResult = await this.DC_build();
+      if (buildResult.exitCode !== 0) {
+        console.error(`[Server_Docker] Build failed: ${buildResult.err}`);
+      } else {
+        console.log(`[Server_Docker] Build completed successfully`);
+      }
+    } catch (error) {
+      console.error(`[Server_Docker] Build error: ${error.message}`);
+    }
     for (const runtime of RUN_TIMES) {
       const serviceName = `${runtime}-builder`;
       console.log(`[Server_Docker] Starting builder service: ${serviceName}`);
       try {
         await this.spawnPromise(`docker compose -f "testeranto/docker-compose.yml" up -d ${serviceName}`);
+        await this.captureExistingLogs(serviceName, runtime);
         this.startServiceLogging(serviceName, runtime).catch((error) => console.error(`[Server_Docker] Failed to start logging for ${serviceName}:`, error));
-        this.captureExistingLogs(serviceName, runtime);
       } catch (error) {
         console.error(`[Server_Docker] Failed to start ${serviceName}: ${error.message}`);
       }
@@ -1267,8 +1290,8 @@ ${x}
         console.log(`[Server_Docker] Starting aider service: ${aiderServiceName} for test ${testName}`);
         try {
           await this.spawnPromise(`docker compose -f "testeranto/docker-compose.yml" up -d ${aiderServiceName}`);
+          await this.captureExistingLogs(aiderServiceName, runtime);
           this.startServiceLogging(aiderServiceName, runtime).catch((error) => console.error(`[Server_Docker] Failed to start logging for ${aiderServiceName}:`, error));
-          this.captureExistingLogs(aiderServiceName, runtime).catch((error) => console.error(`[Server_Docker] Failed to capture existing logs for ${aiderServiceName}:`, error));
         } catch (error) {
           console.error(`[Server_Docker] Failed to start ${aiderServiceName}: ${error.message}`);
         }
@@ -1284,8 +1307,8 @@ ${x}
         console.log(`[Server_Docker] Starting BDD service: ${bddServiceName}, ${configKey}, ${configValue}`);
         try {
           await this.spawnPromise(`docker compose -f "testeranto/docker-compose.yml" up -d ${bddServiceName}`);
+          await this.captureExistingLogs(bddServiceName, runtime);
           this.startServiceLogging(bddServiceName, runtime).catch((error) => console.error(`[Server_Docker] Failed to start logging for ${bddServiceName}:`, error));
-          this.captureExistingLogs(bddServiceName, runtime).catch((error) => console.error(`[Server_Docker] Failed to capture existing logs for ${bddServiceName}:`, error));
         } catch (error) {
           console.error(`[Server_Docker] Failed to start ${bddServiceName}: ${error.message}`);
           this.captureExistingLogs(bddServiceName, runtime).catch((err) => console.error(`[Server_Docker] Also failed to capture logs:`, err));
@@ -1348,8 +1371,10 @@ ${x}
         // 10MB
       });
       if (existingLogs && existingLogs.trim().length > 0) {
-        fs2.appendFileSync(logFilePath, existingLogs);
+        fs2.writeFileSync(logFilePath, existingLogs);
         console.log(`[Server_Docker] Captured ${existingLogs.length} bytes of existing logs for ${serviceName}`);
+      } else {
+        fs2.writeFileSync(logFilePath, "");
       }
       this.captureContainerExitCode(serviceName, reportDir);
     } catch (error) {
@@ -1390,6 +1415,82 @@ ${x}
       throw err;
     }
   }
+  writeConfigForExtension() {
+    try {
+      const configDir = path2.join(process.cwd(), "testeranto");
+      const configPath = path2.join(configDir, "extension-config.json");
+      if (!fs2.existsSync(configDir)) {
+        fs2.mkdirSync(configDir, { recursive: true });
+        console.log(`[Server_Docker] Created directory: ${configDir}`);
+      }
+      console.log(`[Server_Docker] Writing extension config to: ${configPath}`);
+      console.log(`[Server_Docker] Current working directory: ${process.cwd()}`);
+      console.log(`[Server_Docker] Configs runtimes exists: ${!!this.configs.runtimes}`);
+      console.log(`[Server_Docker] Configs runtimes type: ${typeof this.configs.runtimes}`);
+      if (this.configs.runtimes) {
+        console.log(`[Server_Docker] Configs runtimes keys:`, Object.keys(this.configs.runtimes));
+      }
+      const runtimesArray = [];
+      if (this.configs.runtimes && typeof this.configs.runtimes === "object") {
+        for (const [key, value] of Object.entries(this.configs.runtimes)) {
+          console.log(`[Server_Docker] Processing runtime key: ${key}`);
+          console.log(`[Server_Docker] Runtime value type: ${typeof value}`, value);
+          const runtimeObj = value;
+          if (runtimeObj && typeof runtimeObj === "object") {
+            const runtime = runtimeObj.runtime;
+            const tests = runtimeObj.tests || [];
+            console.log(`[Server_Docker] Found runtime: ${runtime}, tests:`, tests);
+            if (runtime) {
+              runtimesArray.push({
+                key,
+                runtime,
+                label: this.getRuntimeLabel(runtime),
+                tests: Array.isArray(tests) ? tests : []
+              });
+            } else {
+              console.warn(`[Server_Docker] No runtime property found for key: ${key}`, runtimeObj);
+            }
+          } else {
+            console.warn(`[Server_Docker] Invalid runtime configuration for key: ${key}, value type: ${typeof value}`);
+          }
+        }
+      } else {
+        console.warn(`[Server_Docker] No runtimes found in config`);
+      }
+      const configData = {
+        runtimes: runtimesArray,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "testeranto.ts",
+        serverStarted: true
+      };
+      const configJson = JSON.stringify(configData, null, 2);
+      fs2.writeFileSync(configPath, configJson);
+      console.log(`[Server_Docker] Successfully wrote extension config to ${configPath} with ${runtimesArray.length} runtimes`);
+      if (fs2.existsSync(configPath)) {
+        const fileStats = fs2.statSync(configPath);
+        console.log(`[Server_Docker] Config file exists, size: ${fileStats.size} bytes`);
+        const fileContent = fs2.readFileSync(configPath, "utf-8");
+        console.log(`[Server_Docker] Config file contents:`, fileContent);
+      } else {
+        console.error(`[Server_Docker] Config file was not created at ${configPath}`);
+      }
+    } catch (error) {
+      console.error(`[Server_Docker] Failed to write extension config:`, error);
+      console.error(`[Server_Docker] Error stack:`, error.stack);
+    }
+  }
+  getRuntimeLabel(runtime) {
+    const labels = {
+      "node": "Node",
+      "web": "Web",
+      "python": "Python",
+      "golang": "Golang",
+      "ruby": "Ruby",
+      "rust": "Rust",
+      "java": "Java"
+    };
+    return labels[runtime] || runtime.charAt(0).toUpperCase() + runtime.slice(1);
+  }
   writeComposeFile(services) {
     const dockerComposeFileContents = this.BaseCompose(services);
     fs2.writeFileSync(

package/dist/ruby/ruby.rb

@@ -0,0 +1,66 @@
+require 'json'
+require 'fileutils'
+
+puts "hello ruby builder", ARGV
+
+# config_file_path is a ruby file
+config_file_path = ARGV[0]
+# Ensure the config file path is valid before requiring
+if File.exist?(config_file_path)
+  require config_file_path
+else
+  puts "Config file not found: #{config_file_path}"
+  exit(1)
+end
+
+test_name = ARGV[1] || "allTests"
+
+# Create necessary directories
+input_files_path = "testeranto/bundles/allTests/ruby/example/Calculator.test.rb-inputFiles.json"
+dummy_ruby_file_path = "testeranto/bundles/allTests/ruby/example/Calculator.test.rb"
+
+# Ensure the directory exists
+FileUtils.mkdir_p(File.dirname(input_files_path))
+FileUtils.mkdir_p(File.dirname(dummy_ruby_file_path))
+
+# Write input files JSON
+input_files_content = {
+  testName: test_name,
+  configFile: config_file_path,
+  timestamp: Time.now.to_i
+}
+File.write(input_files_path, JSON.pretty_generate(input_files_content))
+
+# Write a dummy Ruby file that executes the actual test
+dummy_ruby_content = <<-RUBY
+#!/usr/bin/env ruby
+# This file is generated by the ruby builder
+# It executes the actual Calculator test
+
+require 'json'
+
+# Build the test resource configuration
+config = {
+  name: 'calculator-test',
+  fs: '.',
+  ports: [],
+  timeout: 30000,
+  retries: 0,
+  environment: {}
+}.to_json
+
+# Execute the test file directly with the configuration
+exec("ruby", "../../../../../example/Calculator-test.rb", config)
+RUBY
+
+File.write(dummy_ruby_file_path, dummy_ruby_content)
+File.chmod(0755, dummy_ruby_file_path)
+
+puts "Generated test files:"
+puts "  - #{input_files_path}"
+puts "  - #{dummy_ruby_file_path}"
+
+# Now execute the generated test file
+puts "Executing test..."
+system("ruby #{dummy_ruby_file_path}")
+exit($?.exitstatus)