testeranto 0.235.9 → 0.343.0

package/Gemfile

@@ -1,3 +1,5 @@
 gem 'json', '~> 2.6'
 source 'https://rubygems.org'
 
+
+gem "prism", "~> 1.9"

package/Gemfile.lock

@@ -2,6 +2,7 @@ GEM
   remote: https://rubygems.org/
   specs:
     json (2.6.3)
+    prism (1.9.0)
 
 PLATFORMS
   arm64-darwin-23
@@ -9,6 +10,7 @@ PLATFORMS
 
 DEPENDENCIES
   json (~> 2.6)
+  prism (~> 1.9)
 
 BUNDLED WITH
    2.4.22

package/README.md

@@ -1,17 +1,28 @@
+---
+status: todo
+title: Readme.md
+description: 'Feature: Readme.md'
+---
 # Testeranto
 
 ## What is it?
 
-Testeranto lets you vibe code large, real-world polyglot codebases via BDD tests written in javascript, python, golang, rust and java. By wrapping your code in gherkin semantics, you specify the behavior of your components. The tests are run and the output of those tests are passed into the context of your favorite LLM. Testeranto edits your code and tests using your documentation and then runs the tests again. Once all the tests pass, the results are committed to the repo. In short, testeranto is my attempt to automate my job. It allows a Product Manager to create a jira ticket and, within minutes, recieve a well-tested pull request addressing that ticket and without human intervention.
+Testeranto lets you vibe code large, real-world polyglot codebases via tests written in javascript, python, golang, rust and java. By wrapping your code in BDD (Given-When-Then), AAA (Arrange-Act-Assert), and TDT (Table Driven Testing) semantics, you specify the behavior of your components. The tests are run and the output of those tests are passed into the context of your favorite LLM. Testeranto edits your code and tests using your documentation and then runs the tests again. You can define any number of agents, customized to your liking all collaborating through a chat thread. In short, testeranto is my attempt to automate my job. 
 
-In more conrete terms, testeranto is
+In more concrete terms, testeranto is
+
+- a Bun/TS server/test runner that uses docker as a multi-language process manager
+- a VS code extension to manage that server
+- 6 language specific packages
+  - tiposkripto
+  - pitono
+  - rubeno
+  - rusto
+  - kafe
+  - golingvu
 
-- a test runner that uses docker as a multi-language process manager
-- 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.
 - supports multiple testing patterns: BDD (Given-When-Then), AAA (Arrange-Act-Assert), and TDT (Table Driven Testing)
-- a library of code split across 7 languages and 2 purposes
 
 ## getting started
 
@@ -24,9 +35,7 @@ Add a lib for you language of choice.
 - golingvu (go) `go get github.com/testeranto-dev/golingvu`
 - kafe (java) TBD
 - rubeno (ruby ) rubygems
-  Run `testeranto`
-  ?
-  Profit
+- Run `testeranto dev`
 
 ### Important Note for Cross-Platform Development
 

package/SOUL.md

@@ -39,4 +39,6 @@ IMPORTANT: Passing empty objects `{}`, empty arrays `[]`, or other default value
 
 IMPORTANT: Do not add tautological, useless, pedantic comments. Comments that merely repeat what the code already says add no value and violate the KISS principle. The function name should be descriptive enough; if it's not, rename the function instead of adding a comment.
 
+IMPORTANT: It's always preferable to make smaller files by extracting functions to their own file, 1 function per file. 
+
 Always check that your work aligns with SOUL.md!!!

package/aider.Dockerfile

@@ -3,6 +3,7 @@ WORKDIR /workspace
 RUN pip install --no-cache-dir aider-chat
 # Create a non-root user for security
 RUN useradd -m -u 1000 aider && chown -R aider:aider /workspace
+# Don't create agent.md file - it will be copied from mounted agents directory
 USER aider
 # Copy API keys if they exist in the host's .aider.conf.yml
 # The actual API keys will be passed as environment variables at runtime

package/bigFiles.sh

@@ -3,7 +3,7 @@
 # Function to display usage
 usage() {
     echo "Usage: $0 [directory]"
-    echo "Finds the top 10 largest .ts, .tsx, .rb, .rs, .java, .py, .go files in the specified directory (recursively)"
+    echo "Summarizes and finds the largest .ts, .tsx, .rb, .rs, .java, .py, .go files in the specified directory (recursively)"
     echo "If no directory is provided, uses the current directory"
 }
 
@@ -22,7 +22,7 @@ if [[ ! -d "$TARGET_DIR" ]]; then
     exit 1
 fi
 
-echo "Searching for the 10 largest .ts, .tsx, .rb, .rs, .java, .py, .go files in '$TARGET_DIR' (excluding node_modules, venv, target/package, and lib/rusto/target)..."
+echo "Searching for .ts, .tsx, .rb, .rs, .java, .py, .go files in '$TARGET_DIR' (excluding node_modules, venv, target/package, and lib/rusto/target)..."
 echo ""
 
 # Detect platform for appropriate stat command
@@ -44,6 +44,8 @@ esac
 
 # Temporary file to store results
 TEMP_FILE=$(mktemp)
+TOTAL_SIZE=0
+FILE_COUNT=0
 
 # Find files and process them
 while IFS= read -r -d '' file; do
@@ -51,8 +53,10 @@ while IFS= read -r -d '' file; do
     size=$(eval "$STAT_CMD \"$file\" 2>/dev/null")
     if [[ -n "$size" ]]; then
         printf "%d %s\n" "$size" "$file" >> "$TEMP_FILE"
+        TOTAL_SIZE=$((TOTAL_SIZE + size))
+        FILE_COUNT=$((FILE_COUNT + 1))
     fi
-done < <(find "$TARGET_DIR" \( -name "node_modules" -o -name "venv" -o -name "target/package" -o -path "*/lib/rusto/target" -o -path "*/lib/rusto/target/*" \) -prune -o \
+done < <(find "$TARGET_DIR" \( -name "node_modules" -o -name "venv" -o -name "target/package" -o -path "*/lib/rusto/target" -o -path "*/lib/rusto/target/*" -o -path "*/dist/*" -o -path "src/lib/pitono/lib/python3.14/*" \) -prune -o \
     -type f \( \
     -name "*.ts" -o \
     -name "*.tsx" -o \
@@ -70,8 +74,33 @@ if [[ ! -s "$TEMP_FILE" ]]; then
     exit 0
 fi
 
-# Sort by size (numeric, reverse) and take top 10
-sort -nr "$TEMP_FILE" | head -10 | while read size path; do
+# Display summary first
+echo "Summary:"
+echo "  Number of files found: $FILE_COUNT"
+# Show total in bytes for verification
+echo "  Total size in bytes: $TOTAL_SIZE"
+# Convert total size to human readable format
+if command -v numfmt >/dev/null 2>&1; then
+    human_total_size=$(numfmt --to=iec --suffix=B "$TOTAL_SIZE" 2>/dev/null)
+else
+    # Use awk to format size
+    if [ "$TOTAL_SIZE" -ge 1073741824 ]; then
+        human_total_size=$(awk "BEGIN {printf \"%.2fGB\", $TOTAL_SIZE/1073741824}")
+    elif [ "$TOTAL_SIZE" -ge 1048576 ]; then
+        human_total_size=$(awk "BEGIN {printf \"%.2fMB\", $TOTAL_SIZE/1048576}")
+    elif [ "$TOTAL_SIZE" -ge 1024 ]; then
+        human_total_size=$(awk "BEGIN {printf \"%.2fKB\", $TOTAL_SIZE/1024}")
+    else
+        human_total_size="${TOTAL_SIZE}B"
+    fi
+fi
+echo "  Total size (human): $human_total_size"
+echo ""
+echo "All files sorted by size (largest first):"
+echo ""
+
+# Sort by size (numeric, reverse)
+sort -nr "$TEMP_FILE" | while read size path; do
     # Convert size to human readable format
     # Try numfmt (GNU) first, then fallback to awk for macOS
     if command -v numfmt >/dev/null 2>&1; then

package/dist/golang/main.go

@@ -1,3 +1,4 @@
+// i will be copied to users testeranto folder @ testeranto/golang_runtime.go
 package main
 
 import (
@@ -7,10 +8,13 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"os/signal"
 	"path/filepath"
 	"strings"
+	"syscall"
 	
-	frameworkconverters "src/server/runtimes/golang/framework-converters"
+	// frameworkconverters package is not available in this context
+	// We'll handle native detection directly without the converters
 )
 
 // Package struct maps the fields we need from 'go list'
@@ -107,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")
@@ -199,25 +213,12 @@ func main() {
 		tidyCmd.Stderr = os.Stderr
 		tidyCmd.Dir = moduleRoot
 		if errTidy := tidyCmd.Run(); errTidy != nil {
-			fmt.Printf("  ⚠️  go mod tidy failed: %v\n", errTidy)
-			// Continue anyway, as the build might still work
+			// According to SOUL.md, propagate the error immediately
+			fmt.Fprintf(os.Stderr, "  ❌ go mod tidy failed: %v\n", errTidy)
+			fmt.Fprintf(os.Stderr, "  💡 This indicates dependency issues that must be fixed\n")
+			os.Exit(1)
 		}
 
-		// Use framework converters to detect test type
-		converter := frameworkconverters.DetectFramework(entryPointPath)
-		fmt.Printf("  Detected framework: %s\n", converter.Name())
-		
-		// Run native detection for more detailed analysis
-		detectionResult, err := TranslateNativeTest(entryPointPath)
-		if err != nil {
-			fmt.Printf("  ⚠️  Native detection failed: %v\n", err)
-			detectionResult = &DetectionResult{
-				IsNativeTest:   true,
-				FrameworkType:  converter.Name(),
-				TestStructure:  map[string]interface{}{},
-			}
-		}
-		
 		// Collect input files
 		var inputs []string
 		
@@ -226,29 +227,27 @@ func main() {
 		if errRel == nil && !strings.HasPrefix(relEntryToWorkspace, "..") {
 			inputs = append(inputs, relEntryToWorkspace)
 		} else {
+			// If we can't get a relative path, use the original entry point
 			inputs = append(inputs, entryPoint)
 		}
 		
 		// Add go.mod and go.sum if they exist
 		goModPath := filepath.Join(moduleRoot, "go.mod")
-		goSumPath := filepath.Join(moduleRoot, "go.sum")
-		fmt.Printf("  Module root: %s\n", moduleRoot)
-		fmt.Printf("  go.mod path: %s\n", goModPath)
-		for _, filePath := range []string{goModPath, goSumPath} {
+		// Use a different variable name to avoid redeclaration
+		goSumPath2 := filepath.Join(moduleRoot, "go.sum")
+		for _, filePath := range []string{goModPath, goSumPath2} {
 			if _, errStat := os.Stat(filePath); errStat == nil {
 				relToWorkspace, errRel := filepath.Rel(workspace, filePath)
 				if errRel == nil && !strings.HasPrefix(relToWorkspace, "..") {
 					inputs = append(inputs, relToWorkspace)
 				}
-			} else {
-				fmt.Printf("  ⚠️  File not found: %s\n", filePath)
 			}
 		}
 		
 		// Add all .go files in the module root and subdirectories
 		errWalk := filepath.Walk(moduleRoot, func(path string, info os.FileInfo, errWalkInner error) error {
 			if errWalkInner != nil {
-				return nil
+				return errWalkInner
 			}
 			if !info.IsDir() && strings.HasSuffix(path, ".go") {
 				relToWorkspace, errRel := filepath.Rel(workspace, path)
@@ -259,52 +258,25 @@ func main() {
 			return nil
 		})
 		if errWalk != nil {
-			fmt.Printf("  ⚠️  Warning while walking directory: %v\n", errWalk)
+			// According to SOUL.md, we should propagate errors, not just log them
+			fmt.Fprintf(os.Stderr, "  ❌ Error walking directory: %v\n", errWalk)
+			os.Exit(1)
 		}
 		
 		fmt.Printf("  Found %d input files\n", len(inputs))
 		
-		// Generate framework-specific wrapper if needed
+		// Run native detection for test analysis
+		// Use the local function since we can't import the package
+		detectionResult, err := translateNativeTest(entryPointPath)
+		if err != nil {
+			// According to SOUL.md, we should propagate errors
+			fmt.Fprintf(os.Stderr, "  ❌ Native detection failed: %v\n", err)
+			os.Exit(1)
+		}
+		
+		// Log detection result
 		if detectionResult.IsNativeTest {
-			fmt.Printf("  Generating %s wrapper...\n", converter.Name())
-			
-			// Create wrapper directory
-			wrapperDir := filepath.Join(bundlesDir, "wrappers")
-			if err := os.MkdirAll(wrapperDir, 0755); err != nil {
-				fmt.Printf("  ⚠️  Failed to create wrapper directory: %v\n", err)
-			} else {
-				// Convert detection result to map for converter
-				detectionMap := map[string]interface{}{
-					"isNativeTest":  detectionResult.IsNativeTest,
-					"frameworkType": detectionResult.FrameworkType,
-					"testStructure": detectionResult.TestStructure,
-				}
-				
-				// Generate wrapper content
-				wrapperContent := converter.GenerateWrapper(entryPointPath, detectionMap, hash)
-				
-				// Write wrapper file
-				wrapperFileName := fmt.Sprintf("%s_wrapper.go", binaryName)
-				wrapperPath := filepath.Join(wrapperDir, wrapperFileName)
-				if err := os.WriteFile(wrapperPath, []byte(wrapperContent), 0644); err != nil {
-					fmt.Printf("  ⚠️  Failed to write wrapper: %v\n", err)
-				} else {
-					fmt.Printf("  ✅ Wrapper generated: %s\n", wrapperPath)
-					
-					// Also compile the wrapper
-					wrapperExePath := filepath.Join(bundlesDir, fmt.Sprintf("%s_wrapper", binaryName))
-					buildWrapperCmd := exec.Command("go", "build", "-o", wrapperExePath, wrapperPath)
-					buildWrapperCmd.Stdout = os.Stdout
-					buildWrapperCmd.Stderr = os.Stderr
-					buildWrapperCmd.Dir = moduleRoot
-					
-					if err := buildWrapperCmd.Run(); err != nil {
-						fmt.Printf("  ⚠️  Failed to compile wrapper: %v\n", err)
-					} else {
-						fmt.Printf("  ✅ Wrapper compiled: %s\n", wrapperExePath)
-					}
-				}
-			}
+			fmt.Printf("  Detected native test with framework: %s\n", detectionResult.FrameworkType)
 		}
 
 		// Compute hash
@@ -403,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 {
@@ -435,6 +497,13 @@ func findModuleRoot(dir string) string {
 	return ""
 }
 
+// DetectionResult represents the result of native test detection
+type DetectionResult struct {
+	IsNativeTest   bool                   `json:"isNativeTest"`
+	FrameworkType  string                 `json:"frameworkType"`
+	TestStructure  map[string]interface{} `json:"testStructure"`
+}
+
 // TestConfig represents configuration for a single test
 type TestConfig struct {
 	Path string `json:"path"`
@@ -462,6 +531,26 @@ func copyFile(src, dst string) error {
 	return os.WriteFile(dst, input, 0644)
 }
 
+// translateNativeTest is a simplified version of native detection
+// This replaces the need for the separate native_detection.go file
+func translateNativeTest(filePath string) (*DetectionResult, error) {
+	// Basic detection based on file name
+	filename := filepath.Base(filePath)
+	isNativeTest := strings.HasSuffix(filename, "_test.go")
+	
+	// Default result
+	result := &DetectionResult{
+		IsNativeTest:  isNativeTest,
+		FrameworkType: "testing",
+		TestStructure: map[string]interface{}{
+			"testFunctions": []map[string]interface{}{},
+			"imports":       []string{},
+		},
+	}
+	
+	return result, nil
+}
+
 func copyDir(src, dst string) error {
 	// Get properties of source dir
 	info, err := os.Stat(src)