Using directory local environment for language servers and other functionality

Comienza con el diseño propuesto del protocolo EnvironmentProvider y de EnvironmentProviderStore; en el issue no se nombran archivos de CodeEdit ni tests. Usa como contexto las referencias enlazadas de Zed shell_env.rs y environment.rs y, después, divide el trabajo en las dos etapas indicadas. El trabajo estará terminado cuando los entornos locales al directorio admitan direnv, venv, asdf y dotenv, se pasen a los procesos relevantes y posteriormente puedan ampliarse mediante una API de extensiones.

Description

Environment providers.

I propose a new struct: EnvironmentProviderStore, for the environment providers, which would be used to get the environment for the current directory. This should be implemented in two stages:
a) Implement the API inside of CodeEdit to iron out rough edges, implement support for direnv, venv, asdf and dotenv using it.
b) Create an extension API allowing users to extend CodeEdit with their own environment providers, move existing ones to the extensions

The protocol is as follows:

protocol EnvironmentProvider {
    var displayName { get } 
    func update_env(_ env: [String : String], for directory: FilePath) async throws -> [String: String]
}

Then, based on this protocol, projects should use functions reliant on it to find binaries in path, as well as passing the environment to executed processes

Alternatives Considered

Install everything globally

Additional Context

An example implementation for direnv

import Foundation

struct DirenvProvider: EnvironmentProvider {
    let displayName = "direnv"
    
    func update_env(_ env: [String: String], for directory: FilePath) async throws -> [String: String] {
        let process = Process()
        process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
        process.arguments = ["direnv", "export", "json"]
        process.currentDirectoryURL = URL(fileURLWithPath: directory.string)
        process.environment = env
        
        let pipe = Pipe()
        process.standardOutput = pipe
        process.standardError = Pipe()
        
        try process.run()
        process.waitUntilExit()
        
        guard process.terminationStatus == 0 else {
            throw DirenvError.commandFailed(exitCode: process.terminationStatus)
        }
        
        let data = pipe.fileHandleForReading.readDataToEndOfFile()
        guard let jsonString = String(data: data, encoding: .utf8) else {
            throw DirenvError.invalidOutput
        }
        
        guard let jsonData = jsonString.data(using: .utf8),
              let exportedEnv = try JSONSerialization.jsonObject(with: jsonData) as? [String: String] else {
            throw DirenvError.jsonParsingFailed
        }
        
        var updatedEnv = env
        for (key, value) in exportedEnv {
            updatedEnv[key] = value
        }
        
        return updatedEnv
    }
}

enum DirenvError: Error, LocalizedError {
    case commandFailed(exitCode: Int32)
    case invalidOutput
    case jsonParsingFailed
    
    var errorDescription: String? {
        switch self {
        case .commandFailed(let exitCode):
            return "direnv command failed with exit code \(exitCode)"
        case .invalidOutput:
            return "direnv produced invalid output"
        case .jsonParsingFailed:
            return "Failed to parse direnv JSON output"
        }
    }
}

This should of course be made to asynchronously execute the direnv process but that's mostly details

Zed implementation for reference (it hardcodes direnv and relies on a shell hook for everything else which is explicitly not what I want to do here:
https://github.com/zed-industries/zed/blob/main/crates/util/src/shell_env.rs
https://github.com/zed-industries/zed/blob/main/crates/project/src/environment.rs#L178

Screenshots

No response