Add files using upload-large-folder tool

projects/ui/serena-new/test/resources/repos/java/test_repo/src/main/java/test_repo/ModelUser.java

@@ -0,0 +1,8 @@
+package test_repo;
+
+public class ModelUser {
+    public static void main(String[] args) {
+        Model model = new Model("Cascade");
+        System.out.println(model.getName());
+    }
+}

projects/ui/serena-new/test/resources/repos/java/test_repo/src/main/java/test_repo/Utils.java

@@ -0,0 +1,7 @@
+package test_repo;
+
+public class Utils {
+    public static void printHello() {
+        System.out.println("Hello from Utils!");
+    }
+}

projects/ui/serena-new/test/resources/repos/kotlin/test_repo/build.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    kotlin("jvm") version "1.9.21"
+    application
+}
+
+group = "test.serena"
+version = "1.0-SNAPSHOT"
+
+repositories {
+    mavenCentral()
+}

projects/ui/serena-new/test/resources/repos/kotlin/test_repo/src/main/kotlin/test_repo/Main.kt

@@ -0,0 +1,15 @@
+package test_repo
+
+object Main {
+    @JvmStatic
+    fun main(args: Array<String>) {
+        Utils.printHello()
+        val model = Model("Cascade")
+        println(model.name)
+        acceptModel(model)
+    }
+
+    fun acceptModel(m: Model?) {
+        // Do nothing, just for LSP reference
+    }
+}

projects/ui/serena-new/test/resources/repos/kotlin/test_repo/src/main/kotlin/test_repo/Model.kt

@@ -0,0 +1,3 @@
+package test_repo
+
+data class Model(val name: String)

projects/ui/serena-new/test/resources/repos/kotlin/test_repo/src/main/kotlin/test_repo/ModelUser.kt

@@ -0,0 +1,9 @@
+package test_repo
+
+object ModelUser {
+    @JvmStatic
+    fun main(args: Array<String>) {
+        val model = Model("Cascade")
+        println(model.name)
+    }
+}

projects/ui/serena-new/test/resources/repos/kotlin/test_repo/src/main/kotlin/test_repo/Utils.kt

@@ -0,0 +1,7 @@
+package test_repo
+
+object Utils {
+    fun printHello() {
+        println("Hello from Utils!")
+    }
+}

projects/ui/serena-new/test/resources/repos/lua/test_repo/.gitignore

@@ -0,0 +1,13 @@
+# Lua specific
+*.luac
+.luarocks/
+lua_modules/
+luarocks/
+
+# Build artifacts
+build/
+dist/
+
+# IDE
+.vscode/
+.idea/

projects/ui/serena-new/test/resources/repos/lua/test_repo/main.lua

@@ -0,0 +1,114 @@
+#!/usr/bin/env lua
+
+-- main.lua: Entry point for the test application
+
+local calculator = require("src.calculator")
+local utils = require("src.utils")
+
+local function print_banner()
+    print("=" .. string.rep("=", 40))
+    print("       Lua Test Repository")
+    print("=" .. string.rep("=", 40))
+end
+
+local function test_calculator()
+    print("\nTesting Calculator Module:")
+    print("5 + 3 =", calculator.add(5, 3))
+    print("10 - 4 =", calculator.subtract(10, 4))
+    print("6 * 7 =", calculator.multiply(6, 7))
+    print("15 / 3 =", calculator.divide(15, 3))
+    print("2^8 =", calculator.power(2, 8))
+    print("5! =", calculator.factorial(5))
+    
+    local numbers = {5, 2, 8, 3, 9, 1, 7}
+    print("Mean of", table.concat(numbers, ", "), "=", calculator.mean(numbers))
+    print("Median of", table.concat(numbers, ", "), "=", calculator.median(numbers))
+end
+
+local function test_utils()
+    print("\nTesting Utils Module:")
+    
+    -- String utilities
+    print("Trimmed '  hello  ' =", "'" .. utils.trim("  hello  ") .. "'")
+    local parts = utils.split("apple,banana,orange", ",")
+    print("Split 'apple,banana,orange' by ',' =", table.concat(parts, " | "))
+    print("'hello' starts with 'he' =", utils.starts_with("hello", "he"))
+    print("'world' ends with 'ld' =", utils.ends_with("world", "ld"))
+    
+    -- Table utilities
+    local t1 = {a = 1, b = 2}
+    local t2 = {b = 3, c = 4}
+    local merged = utils.table_merge(t1, t2)
+    print("Merged tables: a=" .. (merged.a or "nil") .. 
+          ", b=" .. (merged.b or "nil") .. 
+          ", c=" .. (merged.c or "nil"))
+    
+    -- Logger
+    local logger = utils.Logger:new("TestApp")
+    logger:info("Application started")
+    logger:debug("Debug information")
+    logger:warn("This is a warning")
+end
+
+local function interactive_calculator()
+    print("\nInteractive Calculator (type 'quit' to exit):")
+    while true do
+        io.write("Enter operation (e.g., '5 + 3'): ")
+        local input = io.read()
+        
+        if input == "quit" then
+            break
+        end
+        
+        -- Simple parser for basic operations
+        local a, op, b = input:match("(%d+)%s*([%+%-%*/])%s*(%d+)")
+        if a and op and b then
+            a = tonumber(a)
+            b = tonumber(b)
+            local result
+            
+            if op == "+" then
+                result = calculator.add(a, b)
+            elseif op == "-" then
+                result = calculator.subtract(a, b)
+            elseif op == "*" then
+                result = calculator.multiply(a, b)
+            elseif op == "/" then
+                local success, res = pcall(calculator.divide, a, b)
+                if success then
+                    result = res
+                else
+                    print("Error: " .. res)
+                    goto continue
+                end
+            end
+            
+            print("Result: " .. result)
+        else
+            print("Invalid input. Please use format: number operator number")
+        end
+        
+        ::continue::
+    end
+end
+
+-- Main execution
+local function main(args)
+    print_banner()
+    
+    if #args == 0 then
+        test_calculator()
+        test_utils()
+    elseif args[1] == "interactive" then
+        interactive_calculator()
+    elseif args[1] == "test" then
+        test_calculator()
+        test_utils()
+        print("\nAll tests completed!")
+    else
+        print("Usage: lua main.lua [interactive|test]")
+    end
+end
+
+-- Run main function
+main(arg or {})

projects/ui/serena-new/test/resources/repos/lua/test_repo/src/calculator.lua

@@ -0,0 +1,76 @@
+-- calculator.lua: A simple calculator module for testing LSP features
+
+local calculator = {}
+
+-- Basic arithmetic operations
+function calculator.add(a, b)
+    return a + b
+end
+
+function calculator.subtract(a, b)
+    return a - b
+end
+
+function calculator.multiply(a, b)
+    return a * b
+end
+
+function calculator.divide(a, b)
+    if b == 0 then
+        error("Division by zero")
+    end
+    return a / b
+end
+
+-- Advanced operations
+function calculator.power(base, exponent)
+    return base ^ exponent
+end
+
+function calculator.factorial(n)
+    if n < 0 then
+        error("Factorial is not defined for negative numbers")
+    elseif n == 0 or n == 1 then
+        return 1
+    else
+        local result = 1
+        for i = 2, n do
+            result = result * i
+        end
+        return result
+    end
+end
+
+-- Statistics functions
+function calculator.mean(numbers)
+    if #numbers == 0 then
+        return nil
+    end
+    
+    local sum = 0
+    for _, num in ipairs(numbers) do
+        sum = sum + num
+    end
+    return sum / #numbers
+end
+
+function calculator.median(numbers)
+    if #numbers == 0 then
+        return nil
+    end
+    
+    local sorted = {}
+    for i, v in ipairs(numbers) do
+        sorted[i] = v
+    end
+    table.sort(sorted)
+    
+    local mid = math.floor(#sorted / 2)
+    if #sorted % 2 == 0 then
+        return (sorted[mid] + sorted[mid + 1]) / 2
+    else
+        return sorted[mid + 1]
+    end
+end
+
+return calculator

projects/ui/serena-new/test/resources/repos/lua/test_repo/src/utils.lua

@@ -0,0 +1,120 @@
+-- utils.lua: Utility functions for the test repository
+
+local utils = {}
+
+-- String utilities
+function utils.trim(s)
+    return s:match("^%s*(.-)%s*$")
+end
+
+function utils.split(str, delimiter)
+    local result = {}
+    local pattern = string.format("([^%s]+)", delimiter)
+    for match in string.gmatch(str, pattern) do
+        table.insert(result, match)
+    end
+    return result
+end
+
+function utils.starts_with(str, prefix)
+    return str:sub(1, #prefix) == prefix
+end
+
+function utils.ends_with(str, suffix)
+    return str:sub(-#suffix) == suffix
+end
+
+-- Table utilities
+function utils.deep_copy(orig)
+    local orig_type = type(orig)
+    local copy
+    if orig_type == 'table' then
+        copy = {}
+        for orig_key, orig_value in next, orig, nil do
+            copy[utils.deep_copy(orig_key)] = utils.deep_copy(orig_value)
+        end
+        setmetatable(copy, utils.deep_copy(getmetatable(orig)))
+    else
+        copy = orig
+    end
+    return copy
+end
+
+function utils.table_contains(tbl, value)
+    for _, v in ipairs(tbl) do
+        if v == value then
+            return true
+        end
+    end
+    return false
+end
+
+function utils.table_merge(t1, t2)
+    local result = {}
+    for k, v in pairs(t1) do
+        result[k] = v
+    end
+    for k, v in pairs(t2) do
+        result[k] = v
+    end
+    return result
+end
+
+-- File utilities
+function utils.read_file(path)
+    local file = io.open(path, "r")
+    if not file then
+        return nil, "Could not open file: " .. path
+    end
+    local content = file:read("*all")
+    file:close()
+    return content
+end
+
+function utils.write_file(path, content)
+    local file = io.open(path, "w")
+    if not file then
+        return false, "Could not open file for writing: " .. path
+    end
+    file:write(content)
+    file:close()
+    return true
+end
+
+-- Class-like structure
+utils.Logger = {}
+utils.Logger.__index = utils.Logger
+
+function utils.Logger:new(name)
+    local self = setmetatable({}, utils.Logger)
+    self.name = name or "default"
+    self.level = "info"
+    return self
+end
+
+function utils.Logger:set_level(level)
+    self.level = level
+end
+
+function utils.Logger:log(message, level)
+    level = level or self.level
+    print(string.format("[%s] %s: %s", self.name, level:upper(), message))
+end
+
+function utils.Logger:debug(message)
+    self:log(message, "debug")
+end
+
+function utils.Logger:info(message)
+    self:log(message, "info")
+end
+
+function utils.Logger:warn(message)
+    self:log(message, "warn")
+end
+
+function utils.Logger:error(message)
+    self:log(message, "error")
+end
+
+return utils

projects/ui/serena-new/test/resources/repos/lua/test_repo/tests/test_calculator.lua

@@ -0,0 +1,93 @@
+-- test_calculator.lua: Unit tests for calculator module
+
+local calculator = require("src.calculator")
+
+local function assert_equals(actual, expected, message)
+    if actual ~= expected then
+        error(string.format("%s: expected %s, got %s", 
+            message or "Assertion failed", tostring(expected), tostring(actual)))
+    end
+end
+
+local function assert_error(func, message)
+    local success = pcall(func)
+    if success then
+        error(string.format("%s: expected error but none was thrown", 
+            message or "Assertion failed"))
+    end
+end
+
+local function test_basic_operations()
+    print("Testing basic operations...")
+    assert_equals(calculator.add(2, 3), 5, "Addition test")
+    assert_equals(calculator.add(-5, 5), 0, "Addition with negative")
+    assert_equals(calculator.add(0, 0), 0, "Addition with zeros")
+    
+    assert_equals(calculator.subtract(10, 3), 7, "Subtraction test")
+    assert_equals(calculator.subtract(5, 10), -5, "Subtraction negative result")
+    
+    assert_equals(calculator.multiply(4, 5), 20, "Multiplication test")
+    assert_equals(calculator.multiply(-3, 4), -12, "Multiplication with negative")
+    assert_equals(calculator.multiply(0, 100), 0, "Multiplication with zero")
+    
+    assert_equals(calculator.divide(10, 2), 5, "Division test")
+    assert_equals(calculator.divide(7, 2), 3.5, "Division with decimal result")
+    assert_error(function() calculator.divide(5, 0) end, "Division by zero")
+    
+    print("✓ Basic operations tests passed")
+end
+
+local function test_advanced_operations()
+    print("Testing advanced operations...")
+    assert_equals(calculator.power(2, 3), 8, "Power test")
+    assert_equals(calculator.power(5, 0), 1, "Power of zero")
+    assert_equals(calculator.power(10, -1), 0.1, "Negative exponent")
+    
+    assert_equals(calculator.factorial(0), 1, "Factorial of 0")
+    assert_equals(calculator.factorial(1), 1, "Factorial of 1")
+    assert_equals(calculator.factorial(5), 120, "Factorial of 5")
+    assert_equals(calculator.factorial(10), 3628800, "Factorial of 10")
+    assert_error(function() calculator.factorial(-1) end, "Factorial of negative")
+    
+    print("✓ Advanced operations tests passed")
+end
+
+local function test_statistics()
+    print("Testing statistics functions...")
+    
+    -- Mean tests
+    assert_equals(calculator.mean({1, 2, 3, 4, 5}), 3, "Mean of sequential numbers")
+    assert_equals(calculator.mean({10}), 10, "Mean of single number")
+    assert_equals(calculator.mean({-5, 5}), 0, "Mean with negatives")
+    assert_equals(calculator.mean({}), nil, "Mean of empty array")
+    
+    -- Median tests
+    assert_equals(calculator.median({1, 2, 3, 4, 5}), 3, "Median of odd count")
+    assert_equals(calculator.median({1, 2, 3, 4}), 2.5, "Median of even count")
+    assert_equals(calculator.median({5, 1, 3, 2, 4}), 3, "Median of unsorted")
+    assert_equals(calculator.median({7}), 7, "Median of single number")
+    assert_equals(calculator.median({}), nil, "Median of empty array")
+    
+    print("✓ Statistics tests passed")
+end
+
+-- Run all tests
+local function run_all_tests()
+    print("Running calculator tests...\n")
+    test_basic_operations()
+    test_advanced_operations()
+    test_statistics()
+    print("\n✅ All calculator tests passed!")
+end
+
+-- Execute tests if run directly
+if arg and arg[0] and arg[0]:match("test_calculator%.lua$") then
+    run_all_tests()
+end
+
+return {
+    run_all_tests = run_all_tests,
+    test_basic_operations = test_basic_operations,
+    test_advanced_operations = test_advanced_operations,
+    test_statistics = test_statistics
+}

projects/ui/serena-new/test/resources/repos/nix/test_repo/.gitignore

@@ -0,0 +1,11 @@
+# Nix specific
+result
+result-*
+.direnv/
+
+# Build artifacts
+*.drv
+
+# IDE
+.vscode/
+.idea/

projects/ui/serena-new/test/resources/repos/nix/test_repo/default.nix

@@ -0,0 +1,183 @@
+# default.nix - Traditional Nix expression for backwards compatibility
+{ pkgs ? import <nixpkgs> { } }:
+
+let
+  # Import library functions
+  lib = pkgs.lib;
+  stdenv = pkgs.stdenv;
+
+  # Import our custom utilities
+  utils = import ./lib/utils.nix { inherit lib; };
+
+  # Custom function to create a greeting
+  makeGreeting = name: "Hello, ${name}!";
+
+  # List manipulation functions (using imported utils)
+  listUtils = {
+    double = list: map (x: x * 2) list;
+    sum = list: lib.foldl' (acc: x: acc + x) 0 list;
+    average = list:
+      if list == [ ]
+      then 0
+      else (listUtils.sum list) / (builtins.length list);
+    # Use function from imported utils
+    unique = utils.lists.unique;
+  };
+
+  # String utilities
+  stringUtils = rec {
+    capitalize = str:
+      let
+        first = lib.substring 0 1 str;
+        rest = lib.substring 1 (-1) str;
+      in
+      (lib.toUpper first) + rest;
+
+    repeat = n: str: lib.concatStrings (lib.genList (_: str) n);
+
+    padLeft = width: char: str:
+      let
+        len = lib.stringLength str;
+        padding = if len >= width then 0 else width - len;
+      in
+      (repeat padding char) + str;
+  };
+
+  # Package builder helper
+  buildSimplePackage = { name, version, script }:
+    stdenv.mkDerivation {
+      pname = name;
+      inherit version;
+
+      phases = [ "installPhase" ];
+
+      installPhase = ''
+        mkdir -p $out/bin
+        cat > $out/bin/${name} << EOF
+        #!/usr/bin/env bash
+        ${script}
+        EOF
+        chmod +x $out/bin/${name}
+      '';
+    };
+
+in
+rec {
+  # Export utilities
+  inherit listUtils stringUtils makeGreeting;
+
+  # Export imported utilities directly
+  inherit (utils) math strings;
+
+  # Example packages
+  hello = buildSimplePackage {
+    name = "hello";
+    version = "1.0";
+    script = ''
+      echo "${makeGreeting "World"}"
+    '';
+  };
+
+  calculator = buildSimplePackage {
+    name = "calculator";
+    version = "0.1";
+    script = ''
+      if [ $# -ne 3 ]; then
+        echo "Usage: calculator <num1> <op> <num2>"
+        exit 1
+      fi
+      
+      case $2 in
+        +) echo $(($1 + $3)) ;;
+        -) echo $(($1 - $3)) ;;
+        x) echo $(($1 * $3)) ;;
+        /) echo $(($1 / $3)) ;;
+        *) echo "Unknown operator: $2" ;;
+      esac
+    '';
+  };
+
+  # Environment with multiple packages
+  devEnv = pkgs.buildEnv {
+    name = "dev-environment";
+    paths = with pkgs; [
+      git
+      vim
+      bash
+      hello
+      calculator
+    ];
+  };
+
+  # Shell derivation
+  shell = pkgs.mkShell {
+    buildInputs = with pkgs; [
+      bash
+      coreutils
+      findutils
+      gnugrep
+      gnused
+    ];
+
+    shellHook = ''
+      echo "Entering Nix shell environment"
+      echo "Available custom functions: makeGreeting, listUtils, stringUtils"
+    '';
+  };
+
+  # Configuration example
+  config = {
+    system = {
+      stateVersion = "23.11";
+      enable = true;
+    };
+
+    services = {
+      nginx = {
+        enable = false;
+        virtualHosts = {
+          "example.com" = {
+            root = "/var/www/example";
+            locations."/" = {
+              index = "index.html";
+            };
+          };
+        };
+      };
+    };
+
+    users = {
+      testUser = {
+        name = "test";
+        group = "users";
+        home = "/home/test";
+        shell = "${pkgs.bash}/bin/bash";
+      };
+    };
+  };
+
+  # Recursive attribute set example
+  tree = {
+    root = {
+      value = 1;
+      left = {
+        value = 2;
+        left = { value = 4; };
+        right = { value = 5; };
+      };
+      right = {
+        value = 3;
+        left = { value = 6; };
+        right = { value = 7; };
+      };
+    };
+
+    # Tree traversal function
+    traverse = node:
+      if node ? left && node ? right
+      then [ node.value ] ++ (tree.traverse node.left) ++ (tree.traverse node.right)
+      else if node ? value
+      then [ node.value ]
+      else [ ];
+  };
+}

projects/ui/serena-new/test/resources/repos/nix/test_repo/flake.nix

@@ -0,0 +1,146 @@
+{
+  description = "Test Nix flake for language server testing";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+        
+        # Import our default.nix for shared logic
+        defaultNix = import ./default.nix { inherit pkgs; };
+        
+        # Custom derivation for testing
+        hello-custom = pkgs.stdenv.mkDerivation {
+          pname = "hello-custom";
+          version = "1.0.0";
+          
+          src = ./.;
+          
+          buildInputs = with pkgs; [
+            bash
+            coreutils
+          ];
+          
+          installPhase = ''
+            mkdir -p $out/bin
+            cp ${./scripts/hello.sh} $out/bin/hello-custom
+            chmod +x $out/bin/hello-custom
+          '';
+          
+          meta = with pkgs.lib; {
+            description = "A custom hello world script";
+            license = licenses.mit;
+            platforms = platforms.all;
+          };
+        };
+        
+        # Development shell configuration
+        devShell = pkgs.mkShell {
+          buildInputs = with pkgs; [
+            # Development tools
+            git
+            gnumake
+            gcc
+            
+            # Nix tools
+            nix-prefetch-git
+            nixpkgs-fmt
+            nil
+            
+            # Languages
+            python3
+            nodejs
+            rustc
+            cargo
+          ];
+          
+          shellHook = ''
+            echo "Welcome to the Nix development shell!"
+            echo "Available tools: git, make, gcc, python3, nodejs, rustc"
+          '';
+        };
+        
+      in
+      {
+        # Packages
+        packages = {
+          default = hello-custom;
+          inherit hello-custom;
+          
+          # Another package for testing
+          utils = pkgs.stdenv.mkDerivation {
+            pname = "test-utils";
+            version = "0.1.0";
+            src = ./.;
+            
+            installPhase = ''
+              mkdir -p $out/share
+              echo "Utility functions" > $out/share/utils.txt
+            '';
+          };
+        };
+        
+        # Apps
+        apps = {
+          default = {
+            type = "app";
+            program = "${hello-custom}/bin/hello-custom";
+          };
+          
+          hello = {
+            type = "app";
+            program = "${hello-custom}/bin/hello-custom";
+          };
+        };
+        
+        # Development shells
+        devShells = {
+          default = devShell;
+          
+          # Minimal shell for testing
+          minimal = pkgs.mkShell {
+            buildInputs = with pkgs; [
+              bash
+              coreutils
+            ];
+          };
+        };
+        
+        # Overlay
+        overlays.default = final: prev: {
+          inherit hello-custom;
+        };
+        
+        # NixOS module
+        nixosModules.default = { config, lib, pkgs, ... }:
+          with lib;
+          {
+            options.services.hello-custom = {
+              enable = mkEnableOption "hello-custom service";
+              
+              message = mkOption {
+                type = types.str;
+                default = "Hello from NixOS!";
+                description = "Message to display";
+              };
+            };
+            
+            config = mkIf config.services.hello-custom.enable {
+              systemd.services.hello-custom = {
+                description = "Hello Custom Service";
+                wantedBy = [ "multi-user.target" ];
+                serviceConfig = {
+                  ExecStart = "${hello-custom}/bin/hello-custom";
+                  Type = "oneshot";
+                };
+              };
+            };
+          };
+      }
+    );
+}

projects/ui/serena-new/test/resources/repos/nix/test_repo/lib/utils.nix

@@ -0,0 +1,165 @@
+# Utility functions library
+{ lib }:
+
+rec {
+  # Math utilities
+  math = {
+    # Calculate factorial
+    factorial = n:
+      if n == 0
+      then 1
+      else n * factorial (n - 1);
+    
+    # Calculate fibonacci number
+    fibonacci = n:
+      if n <= 1
+      then n
+      else (fibonacci (n - 1)) + (fibonacci (n - 2));
+    
+    # Check if number is prime
+    isPrime = n:
+      let
+        checkDivisible = i:
+          if i * i > n then true
+          else if lib.mod n i == 0 then false
+          else checkDivisible (i + 1);
+      in
+        if n <= 1 then false
+        else if n <= 3 then true
+        else checkDivisible 2;
+    
+    # Greatest common divisor
+    gcd = a: b:
+      if b == 0
+      then a
+      else gcd b (lib.mod a b);
+  };
+  
+  # String manipulation
+  strings = {
+    # Reverse a string
+    reverse = str:
+      let
+        len = lib.stringLength str;
+        chars = lib.genList (i: lib.substring (len - i - 1) 1 str) len;
+      in
+        lib.concatStrings chars;
+    
+    # Check if string is palindrome
+    isPalindrome = str:
+      str == strings.reverse str;
+    
+    # Convert to camelCase
+    toCamelCase = str:
+      let
+        words = lib.splitString "-" str;
+        capitalize = w: 
+          if w == "" then ""
+          else (lib.toUpper (lib.substring 0 1 w)) + (lib.substring 1 (-1) w);
+        capitalizedWords = lib.tail (map capitalize words);
+      in
+        (lib.head words) + (lib.concatStrings capitalizedWords);
+    
+    # Convert to snake_case
+    toSnakeCase = str:
+      lib.replaceStrings ["-"] ["_"] (lib.toLower str);
+  };
+  
+  # List operations
+  lists = {
+    # Get unique elements
+    unique = list:
+      lib.foldl' (acc: x:
+        if lib.elem x acc
+        then acc
+        else acc ++ [x]
+      ) [] list;
+    
+    # Zip two lists
+    zip = list1: list2:
+      let
+        len1 = lib.length list1;
+        len2 = lib.length list2;
+        minLen = if len1 < len2 then len1 else len2;
+      in
+        lib.genList (i: {
+          fst = lib.elemAt list1 i;
+          snd = lib.elemAt list2 i;
+        }) minLen;
+    
+    # Flatten nested list
+    flatten = list:
+      lib.foldl' (acc: x:
+        if builtins.isList x
+        then acc ++ (flatten x)
+        else acc ++ [x]
+      ) [] list;
+    
+    # Partition list by predicate
+    partition = pred: list:
+      lib.foldl' (acc: x:
+        if pred x
+        then { yes = acc.yes ++ [x]; no = acc.no; }
+        else { yes = acc.yes; no = acc.no ++ [x]; }
+      ) { yes = []; no = []; } list;
+  };
+  
+  # Attribute set operations
+  attrs = {
+    # Deep merge two attribute sets
+    deepMerge = attr1: attr2:
+      lib.recursiveUpdate attr1 attr2;
+    
+    # Filter attributes by predicate
+    filterAttrs = pred: attrs:
+      lib.filterAttrs pred attrs;
+    
+    # Map over attribute values
+    mapValues = f: attrs:
+      lib.mapAttrs (name: value: f value) attrs;
+    
+    # Get nested attribute safely
+    getAttrPath = path: default: attrs:
+      lib.attrByPath path default attrs;
+  };
+  
+  # File system utilities
+  files = {
+    # Read JSON file
+    readJSON = path:
+      builtins.fromJSON (builtins.readFile path);
+    
+    # Read TOML file
+    readTOML = path:
+      builtins.fromTOML (builtins.readFile path);
+    
+    # Check if path exists
+    pathExists = path:
+      builtins.pathExists path;
+    
+    # Get file type
+    getFileType = path:
+      let
+        type = builtins.readFileType path;
+      in
+        if type == "directory" then "dir"
+        else if type == "regular" then "file"
+        else if type == "symlink" then "link"
+        else "unknown";
+  };
+  
+  # Validation utilities
+  validate = {
+    # Check if value is email
+    isEmail = str:
+      builtins.match "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$" str != null;
+    
+    # Check if value is URL
+    isURL = str:
+      builtins.match "^https?://[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}" str != null;
+    
+    # Check if value is valid version
+    isVersion = str:
+      builtins.match "^[0-9]+\\.[0-9]+\\.[0-9]+$" str != null;
+  };
+}

projects/ui/serena-new/test/resources/repos/nix/test_repo/modules/example.nix

@@ -0,0 +1,145 @@
+# Example NixOS module
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.example;
+  
+  # Helper function to generate config file
+  generateConfig = settings: ''
+    # Generated configuration
+    ${lib.concatStringsSep "\n" (lib.mapAttrsToList (k: v: "${k} = ${toString v}") settings)}
+  '';
+  
+in {
+  # Module options
+  options = {
+    services.example = {
+      enable = mkEnableOption "example service";
+      
+      package = mkOption {
+        type = types.package;
+        default = pkgs.hello;
+        description = "Package to use for the service";
+      };
+      
+      port = mkOption {
+        type = types.port;
+        default = 8080;
+        description = "Port to listen on";
+      };
+      
+      host = mkOption {
+        type = types.str;
+        default = "localhost";
+        description = "Host to bind to";
+      };
+      
+      workers = mkOption {
+        type = types.int;
+        default = 4;
+        description = "Number of worker processes";
+      };
+      
+      settings = mkOption {
+        type = types.attrsOf types.anything;
+        default = {};
+        description = "Additional settings";
+      };
+      
+      users = mkOption {
+        type = types.listOf types.str;
+        default = [];
+        description = "List of users with access";
+      };
+      
+      database = {
+        enable = mkOption {
+          type = types.bool;
+          default = false;
+          description = "Enable database support";
+        };
+        
+        type = mkOption {
+          type = types.enum [ "postgresql" "mysql" "sqlite" ];
+          default = "sqlite";
+          description = "Database type";
+        };
+        
+        host = mkOption {
+          type = types.str;
+          default = "localhost";
+          description = "Database host";
+        };
+        
+        name = mkOption {
+          type = types.str;
+          default = "example";
+          description = "Database name";
+        };
+      };
+    };
+  };
+  
+  # Module configuration
+  config = mkIf cfg.enable {
+    # System packages
+    environment.systemPackages = [ cfg.package ];
+    
+    # Systemd service
+    systemd.services.example = {
+      description = "Example Service";
+      after = [ "network.target" ] ++ (optional cfg.database.enable "postgresql.service");
+      wantedBy = [ "multi-user.target" ];
+      
+      serviceConfig = {
+        Type = "simple";
+        User = "example";
+        Group = "example";
+        ExecStart = "${cfg.package}/bin/example --port ${toString cfg.port} --host ${cfg.host}";
+        Restart = "on-failure";
+        RestartSec = 5;
+        
+        # Security hardening
+        PrivateTmp = true;
+        ProtectSystem = "strict";
+        ProtectHome = true;
+        NoNewPrivileges = true;
+      };
+      
+      environment = {
+        EXAMPLE_WORKERS = toString cfg.workers;
+        EXAMPLE_CONFIG = generateConfig cfg.settings;
+      } // optionalAttrs cfg.database.enable {
+        DATABASE_TYPE = cfg.database.type;
+        DATABASE_HOST = cfg.database.host;
+        DATABASE_NAME = cfg.database.name;
+      };
+    };
+    
+    # User and group
+    users.users.example = {
+      isSystemUser = true;
+      group = "example";
+      description = "Example service user";
+    };
+    
+    users.groups.example = {};
+    
+    # Firewall rules
+    networking.firewall = mkIf (cfg.host == "0.0.0.0") {
+      allowedTCPPorts = [ cfg.port ];
+    };
+    
+    # Database setup
+    services.postgresql = mkIf (cfg.database.enable && cfg.database.type == "postgresql") {
+      enable = true;
+      ensureDatabases = [ cfg.database.name ];
+      ensureUsers = [{
+        name = "example";
+        ensureDBOwnership = true;
+      }];
+    };
+  };
+}

projects/ui/serena-new/test/resources/repos/nix/test_repo/scripts/hello.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Simple hello script for testing
+echo "Hello from Nix!"

projects/ui/serena-new/test/resources/repos/php/test_repo/helper.php

@@ -0,0 +1,7 @@
+<?php
+
+function helperFunction(): void {
+    echo "Helper function was called.";
+}
+
+?> 

projects/ui/serena-new/test/resources/repos/php/test_repo/index.php

@@ -0,0 +1,20 @@
+<?php
+
+require_once 'helper.php';
+
+function greet(string $name): string {
+    return "Hello, " . $name . "!";
+}
+
+$userName = "PHP User";
+$greeting = greet($userName);
+
+echo $greeting;
+
+helperFunction();
+
+function useHelperFunction() {
+    helperFunction();
+}
+
+?>