@sriinnu/runic 1.2.0 → 2.11.1

package/Packages/Helix/Sources/Helix/Platform/PlatformPath.swift

@@ -1,167 +0,0 @@
-import Foundation
-
-/// Represents a file system path in a cross-platform manner.
-public struct PlatformPath: Sendable, ExpressibleFromArgument {
-    private let path: String
-
-    /// Creates a path from a string.
-    public init(_ path: String) {
-        self.path = Self.normalize(path)
-    }
-
-    /// Creates a path from a string argument.
-    public init?(argument: String) {
-        self.init(argument)
-    }
-
-    // MARK: - Normalization
-
-    private static func normalize(_ path: String) -> String {
-        #if os(Windows)
-        // Windows accepts both forward and backslashes, normalize to backslashes
-        return path.replacingOccurrences(of: "/", with: "\\")
-        #else
-        return path
-        #endif
-    }
-
-    // MARK: - Properties
-
-    /// Whether the path is absolute.
-    public var isAbsolute: Bool {
-        #if os(Windows)
-        if path.hasPrefix("\\") {
-            return true
-        }
-        // Check for drive letter (e.g., C:)
-        if path.count >= 2 {
-            let secondChar = path[path.index(after: path.startIndex)]
-            return secondChar == ":"
-        }
-        return false
-        #else
-        return path.hasPrefix("/")
-        #endif
-    }
-
-    /// The last component of the path.
-    public var lastComponent: String {
-        #if os(Windows)
-        let parts = path.split(separator: "\\", omittingEmptySubsequences: false)
-        return parts.last.map(String.init) ?? path
-        #else
-        let parts = path.split(separator: "/", omittingEmptySubsequences: false)
-        return parts.last.map(String.init) ?? path
-        #endif
-    }
-
-    /// The file extension.
-    public var `extension`: String? {
-        let components = lastComponent.split(separator: ".")
-        guard components.count > 1 else { return nil }
-        return String(components.last!)
-    }
-
-    /// The path without the final extension.
-    public var deletingExtension: PlatformPath {
-        guard let ext = self.extension else { return self }
-        let withoutExt = lastComponent.dropLast(ext.count + 1)
-        return PlatformPath(path.dropLast(withoutExt.count + ext.count + 1) + String(withoutExt))
-    }
-
-    // MARK: - Path Operations
-
-    /// Appends a component to the path.
-    public func appending(_ component: String) -> PlatformPath {
-        let separator: String
-        #if os(Windows)
-        separator = "\\"
-        #else
-        separator = "/"
-        #endif
-
-        var result = path
-        if !result.isEmpty && !result.hasSuffix(separator) {
-            result += separator
-        }
-        return PlatformPath(result + component)
-    }
-
-    /// Resolves the path to an absolute path.
-    public func resolvingRelativeTo(_ base: PlatformPath) -> PlatformPath {
-        if isAbsolute {
-            return self
-        }
-        return base.appending(path)
-    }
-
-    // MARK: - String Conversion
-
-    public var string: String {
-        path
-    }
-
-    public var description: String {
-        path
-    }
-}
-
-// MARK: - Path Joining
-
-public extension PlatformPath {
-    /// Joins multiple path components.
-    static func joining(_ components: String...) -> PlatformPath {
-        components.reduce(PlatformPath("")) { $0.appending($1) }
-    }
-}
-
-// MARK: - Environment Variable Expansion
-
-extension PlatformPath {
-    /// Expands environment variables in the path.
-    /// - Parameter environment: A dictionary of environment variables.
-    /// - Returns: A new path with variables expanded.
-    public func expandingEnvironmentVariables(_ environment: [String: String]) -> PlatformPath {
-        var result = path
-        for (key, value) in environment {
-            let variable = "$" + key
-            result = result.replacingOccurrences(of: variable, with: value)
-            #if os(Windows)
-            let windowsVariable = "%" + key + "%"
-            result = result.replacingOccurrences(of: windowsVariable, with: value)
-            #endif
-        }
-        return PlatformPath(result)
-    }
-
-    /// Expands the home directory (~) in the path.
-    /// - Parameter homeDirectory: The home directory path.
-    /// - Returns: A new path with ~ expanded.
-    public func expandingHomeDirectory(_ homeDirectory: PlatformPath) -> PlatformPath {
-        guard path.hasPrefix("~") else { return self }
-        return homeDirectory.appending(String(path.dropFirst()))
-    }
-}
-
-// MARK: - Platform-Specific Home Directory
-
-extension PlatformPath {
-    /// The user's home directory.
-    public static var homeDirectory: PlatformPath {
-        #if os(Windows)
-        if let home = DefaultPlatformContext.shared.environmentVariable("USERPROFILE") {
-            return PlatformPath(home)
-        }
-        if let home = DefaultPlatformContext.shared.environmentVariable("HOMEPATH") {
-            let drive = DefaultPlatformContext.shared.environmentVariable("HOMEDRIVE") ?? ""
-            return PlatformPath(drive + home)
-        }
-        return PlatformPath("")
-        #else
-        if let home = DefaultPlatformContext.shared.environmentVariable("HOME") {
-            return PlatformPath(home)
-        }
-        return PlatformPath("")
-        #endif
-    }
-}

package/Packages/Helix/Sources/Helix/Platform/Stdio.swift

@@ -1,99 +0,0 @@
-import Foundation
-
-// MARK: - Stdio Stream
-
-/// Represents a standard I/O stream (stdin, stdout, stderr).
-public protocol StdioStream: Sendable {
-    /// Reads data from the stream.
-    func read(upToCount count: Int) throws -> Data?
-
-    /// Writes data to the stream.
-    func write(_ data: Data) throws
-
-    /// Flushes any buffered output.
-    func flush() throws
-}
-
-// MARK: - File Handle Stream
-
-/// A StdioStream backed by a FileHandle.
-public struct FileHandleStdioStream: StdioStream {
-    public enum StreamType {
-        case stdin
-        case stdout
-        case stderr
-    }
-
-    private let fileHandle: FileHandle
-
-    public init(_ type: StreamType) {
-        switch type {
-        case .stdin:
-            self.fileHandle = FileHandle.standardInput
-        case .stdout:
-            self.fileHandle = FileHandle.standardOutput
-        case .stderr:
-            self.fileHandle = FileHandle.standardError
-        }
-    }
-
-    public func read(upToCount count: Int) throws -> Data? {
-        fileHandle.readData(ofLength: count)
-    }
-
-    public func write(_ data: Data) throws {
-        try fileHandle.write(contentsOf: data)
-    }
-
-    public func flush() throws {
-        fileHandle.synchronizeFile()
-    }
-}
-
-// MARK: - Buffer Stream
-
-/// An in-memory stream for testing or capturing output.
-public final class BufferStdioStream: @unchecked Sendable, StdioStream {
-    private let lock = NSLock()
-    private var buffer: Data
-    private var inputBuffer: Data
-    private var inputIndex: Int = 0
-
-    public init(input: Data = Data()) {
-        self.buffer = Data()
-        self.inputBuffer = input
-    }
-
-    public var output: Data {
-        lock.lock()
-        defer { lock.unlock() }
-        return buffer
-    }
-
-    public var outputString: String? {
-        lock.lock()
-        defer { lock.unlock() }
-        return String(data: buffer, encoding: .utf8)
-    }
-
-    public func read(upToCount count: Int) throws -> Data? {
-        lock.lock()
-        defer { lock.unlock() }
-        let remaining = inputBuffer.count - inputIndex
-        guard remaining > 0 else { return nil }
-        let toRead = min(count, remaining)
-        let slice = inputBuffer.subdata(in: inputIndex..<(inputIndex + toRead))
-        inputIndex += toRead
-        return slice
-    }
-
-    public func write(_ data: Data) throws {
-        lock.lock()
-        defer { lock.unlock() }
-        buffer.append(data)
-    }
-
-    public func flush() throws {
-        // No-op for buffer
-    }
-}

package/Packages/Helix/Sources/Helix/Platform/WebPlatformContext.swift

@@ -1,146 +0,0 @@
-import Foundation
-
-#if os(WASI)
-
-/// Platform context implementation for WebAssembly (WASI).
-public struct WebPlatformContext: PlatformContext {
-
-    /// Creates a new WebAssembly platform context.
-    public init() {}
-
-    public var arguments: [String] {
-        // WASI provides arguments via the runtime (CommandLine.arguments).
-        let args = CommandLine.arguments
-        if args.count > 1 {
-            return Array(args.dropFirst())
-        }
-        // Arguments can also be provided via JavaScript interop or query params.
-        #if canImport(JavaScriptKit)
-        return WASMArguments.getArguments()
-        #else
-        return []
-        #endif
-    }
-
-    public func environmentVariable(_ name: String) -> String? {
-        return ProcessInfo.processInfo.environment[name]
-    }
-
-    public var stdin: StdioStream {
-        WebStdioStream(type: .stdin)
-    }
-
-    public var stdout: StdioStream {
-        WebStdioStream(type: .stdout)
-    }
-
-    public var stderr: StdioStream {
-        WebStdioStream(type: .stderr)
-    }
-
-    public func exit(code: Int32) -> Never {
-        // WASM can't actually exit; trap instead.
-        fatalError("WebAssembly exit(\(code))")
-    }
-
-    public var currentWorkingDirectory: PlatformPath {
-        // WASM has no file system concept
-        return PlatformPath("/")
-    }
-}
-
-// MARK: - Web Stdio Stream
-
-#if canImport(JavaScriptKit)
-import JavaScriptKit
-
-struct WebStdioStream: StdioStream {
-    enum StreamType {
-        case stdin
-        case stdout
-        case stderr
-    }
-
-    let type: StreamType
-
-    func read(upToCount count: Int) throws -> Data? {
-        // JavaScript interop for reading stdin would go here
-        return nil
-    }
-
-    func write(_ data: Data) throws {
-        guard let string = String(data: data, encoding: .utf8) else { return }
-
-        switch type {
-        case .stdout:
-            JavaScriptKit.console.log(string)
-        case .stderr:
-            JavaScriptKit.console.error(string)
-        case .stdin:
-            break // Can't write to stdin
-        }
-    }
-
-    func flush() throws {
-        // No-op for web
-    }
-}
-
-#elseif FOUNDATION_FRAMEWORK
-
-import Foundation
-
-struct WebStdioStream: StdioStream {
-    enum StreamType {
-        case stdin
-        case stdout
-        case stderr
-    }
-
-    let type: StreamType
-
-    func read(upToCount count: Int) throws -> Data? {
-        return nil
-    }
-
-    func write(_ data: Data) throws {
-        guard let string = String(data: data, encoding: .utf8) else { return }
-
-        // Use Foundation's file descriptor to write to console
-        switch type {
-        case .stdout:
-            FileHandle.standardOutput.write(data)
-        case .stderr:
-            FileHandle.standardError.write(data)
-        case .stdin:
-            break
-        }
-    }
-
-    func flush() throws {
-        switch type {
-        case .stdout:
-            FileHandle.standardOutput.synchronizeFile()
-        case .stderr:
-            FileHandle.standardError.synchronizeFile()
-        case .stdin:
-            break
-        }
-    }
-}
-
-#endif
-
-// MARK: - WASM Arguments Helper
-
-#if canImport(JavaScriptKit)
-enum WASMArguments {
-    static func getArguments() -> [String] {
-        // This would use JavaScriptKit to access arguments
-        // passed via the `args` property in wasi_snapshot_preview1
-        return []
-    }
-}
-#endif
-
-#endif

package/Packages/Helix/Sources/Helix/Platform/WindowsPlatformContext.swift

@@ -1,97 +0,0 @@
-import Foundation
-
-#if os(Windows)
-
-import WinSDK
-
-/// Platform context implementation for Windows.
-public struct WindowsPlatformContext: PlatformContext {
-
-    /// Creates a new Windows platform context.
-    public init() {}
-
-    public var arguments: [String] {
-        let argc = Int(CommandLine.argc)
-        var result: [String] = []
-
-        for i in 0..<argc {
-            guard let arg = CommandLine.unsafeArgv[i] else { continue }
-            if let str = String(validatingUTF8: arg) {
-                result.append(str)
-            }
-        }
-
-        return Array(result.dropFirst())
-    }
-
-    public func environmentVariable(_ name: String) -> String? {
-        // Windows API uses UTF-16 and reports lengths including the null terminator.
-        var wideName = Array(name.utf16)
-        wideName.append(0)
-
-        return wideName.withUnsafeBufferPointer { namePtr in
-            let required = GetEnvironmentVariableW(namePtr.baseAddress, nil, 0)
-            if required == 0 {
-                let err = GetLastError()
-                if err == ERROR_ENVVAR_NOT_FOUND {
-                    return nil
-                }
-                // Variable exists but empty (or another non-not-found error).
-                return ""
-            }
-
-            var buffer = UnsafeMutablePointer<UInt16>.allocate(capacity: Int(required))
-            defer { buffer.deallocate() }
-
-            var copied = GetEnvironmentVariableW(namePtr.baseAddress, buffer, required)
-            if copied >= required {
-                buffer.deallocate()
-                buffer = UnsafeMutablePointer<UInt16>.allocate(capacity: Int(copied + 1))
-                copied = GetEnvironmentVariableW(namePtr.baseAddress, buffer, copied + 1)
-            }
-
-            if copied == 0 {
-                let err = GetLastError()
-                if err == ERROR_ENVVAR_NOT_FOUND {
-                    return nil
-                }
-                return ""
-            }
-
-            return String(decoding: UnsafeBufferPointer(start: buffer, count: Int(copied)), as: UTF16.self)
-        }
-    }
-
-    public var stdin: StdioStream {
-        FileHandleStdioStream(.stdin)
-    }
-
-    public var stdout: StdioStream {
-        FileHandleStdioStream(.stdout)
-    }
-
-    public var stderr: StdioStream {
-        FileHandleStdioStream(.stderr)
-    }
-
-    public func exit(code: Int32) -> Never {
-        ExitProcess(UInt32(code))
-    }
-
-    public var currentWorkingDirectory: PlatformPath {
-        let required = GetCurrentDirectoryW(0, nil)
-        guard required > 0 else { return PlatformPath("") }
-
-        let capacity = Int(required + 1)
-        let buffer = UnsafeMutablePointer<UInt16>.allocate(capacity: capacity)
-        defer { buffer.deallocate() }
-
-        let copied = GetCurrentDirectoryW(UInt32(capacity), buffer)
-        guard copied > 0 else { return PlatformPath("") }
-
-        let path = String(decoding: UnsafeBufferPointer(start: buffer, count: Int(copied)), as: UTF16.self)
-        return PlatformPath(path)
-    }
-}
-
-#endif