@sriinnu/runic 1.0.0

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

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,97 @@
+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