@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/kernels/jl/prelude.jl

@@ -0,0 +1,283 @@
+# allow: SIZE_OK — this dependency-free kernel prelude is loaded as one runtime asset.
+const SENPI_B64_ALPHABET = collect("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
+
+function senpi_base64(text::AbstractString)
+    bytes = codeunits(text)
+    out = IOBuffer()
+    index = 1
+    while index <= length(bytes)
+        first_byte = bytes[index]
+        second_byte = index + 1 <= length(bytes) ? bytes[index + 1] : UInt8(0)
+        third_byte = index + 2 <= length(bytes) ? bytes[index + 2] : UInt8(0)
+        Base.write(out, SENPI_B64_ALPHABET[(first_byte >> 2) + 1])
+        Base.write(out, SENPI_B64_ALPHABET[(((first_byte & 0x03) << 4) | (second_byte >> 4)) + 1])
+        Base.write(out, index + 1 <= length(bytes) ? SENPI_B64_ALPHABET[(((second_byte & 0x0f) << 2) | (third_byte >> 6)) + 1] : '=')
+        Base.write(out, index + 2 <= length(bytes) ? SENPI_B64_ALPHABET[(third_byte & 0x3f) + 1] : '=')
+        index += 3
+    end
+    String(take!(out))
+end
+
+function senpi_status_events_enabled()
+    get(senpi_connection, "statusEvents", true) !== false
+end
+
+function senpi_emit_status(op::AbstractString, fields::AbstractDict=Dict{String, Any}(); force::Bool=false)
+    (force || senpi_status_events_enabled()) || return nothing
+    event = Dict{String, Any}("op" => string(op))
+    for (key, value) in fields
+        event[string(key)] = value
+    end
+    senpi_emit(Dict("type" => "status", "event" => event))
+    nothing
+end
+
+function senpi_with_bridge_timeout_pause(operation::Function)
+    senpi_emit_status("timeout-pause"; force=true)
+    try
+        return operation()
+    finally
+        senpi_emit_status("timeout-resume"; force=true)
+    end
+end
+
+function senpi_url_decode(value::AbstractString)
+    out = IOBuffer()
+    index = 1
+    while index <= ncodeunits(value)
+        character = Char(codeunit(value, index))
+        if character == '%' && index + 2 <= ncodeunits(value)
+            hex = value[index + 1:index + 2]
+            parsed = tryparse(UInt8, hex; base=16)
+            if parsed !== nothing
+                Base.write(out, parsed)
+                index += 3
+                continue
+            end
+        end
+        Base.write(out, character)
+        index += 1
+    end
+    String(take!(out))
+end
+
+function senpi_resolve_path(value::AbstractString)
+    raw = string(value)
+    matched = match(r"^([a-z][a-z0-9+.\-]*)://(.*)$"i, raw)
+    matched === nothing && return abspath(raw)
+    scheme = lowercase(string(matched.captures[1]))
+    roots = get(senpi_connection, "localRoots", nothing)
+    root = roots isa AbstractDict ? get(roots, scheme, nothing) : nothing
+    root isa AbstractString && !isempty(root) || error("Protocol paths are not supported by this helper: $raw")
+    relative = senpi_url_decode(replace(string(matched.captures[2]), '\\' => '/'))
+    root_path = abspath(string(root))
+    isempty(relative) && return root_path
+    (startswith(relative, '/') || ".." in split(relative, '/')) && error("Unsafe $scheme:// path (absolute or traversal): $raw")
+    resolved = abspath(joinpath(root_path, relative))
+    (resolved == root_path || startswith(resolved, root_path * string(Base.Filesystem.path_separator))) || error("$scheme:// path escapes its root: $raw")
+    resolved
+end
+
+function senpi_display_payload(value)
+    if value isa AbstractDict
+        kind = get(value, "type", get(value, :type, nothing))
+        text_value = get(value, "text", get(value, :text, nothing))
+        if kind == "markdown" && text_value !== nothing
+            return "text/markdown", string(text_value), false
+        end
+        mime_type = get(value, "mimeType", get(value, :mimeType, nothing))
+        data = get(value, "data", get(value, :data, nothing))
+        if kind == "image" && mime_type isa AbstractString && data !== nothing
+            return string(mime_type), string(data), true
+        end
+        return "application/json", senpi_json(value), false
+    end
+    value isa AbstractVector && return "application/json", senpi_json(value), false
+    "text/plain", string(value), false
+end
+
+function display(value)
+    mime_type, payload, encoded = senpi_display_payload(value)
+    senpi_emit(Dict("type" => "display", "mimeType" => mime_type, "dataBase64" => encoded ? payload : senpi_base64(payload)))
+    nothing
+end
+
+function display_image(base64_value::AbstractString, mime_type::AbstractString="image/png")
+    senpi_emit(Dict("type" => "display", "mimeType" => string(mime_type), "dataBase64" => string(base64_value)))
+    nothing
+end
+
+function text(value)
+    senpi_emit(Dict("type" => "text", "stream" => "stdout", "data" => string(value)))
+    nothing
+end
+
+function print(values...)
+    text(join(string.(values), ""))
+end
+
+function read(path::AbstractString, offset::Integer=1, limit::Union{Integer, Nothing}=nothing)
+    resolved = senpi_resolve_path(path)
+    content = Base.read(resolved, String)
+    if offset > 1 || limit !== nothing
+        lines = split(content, '\n'; keepempty=true)
+        start = max(1, Int(offset))
+        finish = limit === nothing ? length(lines) : min(length(lines), start + Int(limit) - 1)
+        content = start <= length(lines) ? join(lines[start:finish], '\n') : ""
+    end
+    senpi_emit_status("read", Dict("path" => resolved, "chars" => length(content), "preview" => first(content, min(length(content), 500))))
+    content
+end
+
+function write(path::AbstractString, content)
+    resolved = senpi_resolve_path(path)
+    mkpath(dirname(resolved))
+    data = string(content)
+    open(resolved, "w") do io
+        Base.write(io, data)
+    end
+    senpi_emit_status("write", Dict("path" => resolved, "chars" => length(data)))
+    resolved
+end
+
+function env(key=nothing, value=nothing)
+    if key === nothing
+        values = Dict{String, String}(string(name) => string(item) for (name, item) in ENV)
+        senpi_emit_status("env", Dict("count" => length(values), "keys" => sort(collect(keys(values)))[1:min(20, length(values))]))
+        return values
+    end
+    name = string(key)
+    if value === nothing
+        resolved = get(ENV, name, nothing)
+        senpi_emit_status("env", Dict("key" => name, "value" => resolved, "action" => "get"))
+        return resolved
+    end
+    resolved = string(value)
+    ENV[name] = resolved
+    senpi_emit_status("env", Dict("key" => name, "value" => resolved, "action" => "set"))
+    resolved
+end
+
+struct SenpiToolProxy end
+
+struct SenpiToolCallable
+    name::String
+end
+
+function (callable::SenpiToolCallable)(args=nothing; kwargs...)
+    values = Dict{String, Any}()
+    if args !== nothing
+        args isa AbstractDict || error("tool.$(callable.name)(...) expects a dictionary of arguments")
+        for (key, value) in args
+            values[string(key)] = value
+        end
+    end
+    for (key, value) in kwargs
+        values[string(key)] = value
+    end
+    senpi_with_bridge_timeout_pause(() -> senpi_call_tool(callable.name, values))
+end
+
+Base.getproperty(::SenpiToolProxy, name::Symbol) = SenpiToolCallable(string(name))
+const tool = SenpiToolProxy()
+
+function completion(prompt::AbstractString; model="default", system=nothing, schema=nothing, kwargs...)
+    options = Dict{String, Any}("model" => model)
+    system !== nothing && (options["system"] = system)
+    schema !== nothing && (options["schema"] = schema)
+    for (key, value) in kwargs
+        options[string(key)] = value
+    end
+    response = senpi_with_bridge_timeout_pause(() -> senpi_completion(string(prompt), options))
+    response isa AbstractDict || return response
+    haskey(response, "value") && return response["value"]
+    get(response, "text", response)
+end
+
+function output(ids...; format="raw", offset=nothing, limit=nothing)
+    isempty(ids) && error("At least one output ID is required")
+    format in ("raw", "tail") || error("output() format must be 'raw' or 'tail'")
+    arguments = Dict{String, Any}("ids" => string.(ids), "format" => format)
+    offset !== nothing && (arguments["offset"] = offset)
+    limit !== nothing && (arguments["limit"] = limit)
+    senpi_with_bridge_timeout_pause(() -> senpi_call_tool("__output__", arguments))
+end
+
+function agent(prompt::AbstractString; agent="task", model=nothing, label=nothing, schema=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
+    arguments = Dict{String, Any}("prompt" => string(prompt), "agent" => agent)
+    for (key, value) in (("model", model), ("label", label), ("schema", schema), ("isolated", isolated), ("apply", apply), ("merge", merge))
+        value !== nothing && (arguments[key] = value)
+    end
+    for (key, value) in kwargs
+        arguments[string(key)] = value
+    end
+    handle && (arguments["handle"] = true)
+    response = senpi_with_bridge_timeout_pause(() -> senpi_call_tool("__agent__", arguments))
+    record = response isa AbstractDict ? response : Dict{String, Any}()
+    text_value = get(record, "text", response)
+    parsed = schema === nothing ? text_value : haskey(record, "data") ? record["data"] : senpi_json_parse(string(text_value))
+    handle || return parsed
+    result = Dict{String, Any}("text" => text_value, "output" => text_value, "id" => get(record, "id", nothing), "agent" => get(record, "agent", agent))
+    result["handle"] = get(record, "handle", result["id"] === nothing ? nothing : "agent://" * string(result["id"]))
+    schema !== nothing && (result["data"] = parsed)
+    result
+end
+
+function senpi_pool_map(items, callback)
+    values = collect(items)
+    isempty(values) && return Any[]
+    configured_width = get(senpi_connection, "parallelPoolWidth", 4)
+    width = configured_width isa Real && isfinite(configured_width) ? Int(floor(configured_width)) : 4
+    workers = min(max(width, 1), length(values))
+    tokens = Channel{Nothing}(workers)
+    for _ in 1:workers
+        put!(tokens, nothing)
+    end
+    results = Vector{Any}(undef, length(values))
+    errors = Dict{Int, Any}()
+    lock = ReentrantLock()
+    @sync for index in eachindex(values)
+        @async begin
+            take!(tokens)
+            try
+                results[index] = callback(values[index])
+            catch error
+                Base.lock(lock) do
+                    errors[index] = error
+                end
+            finally
+                put!(tokens, nothing)
+            end
+        end
+    end
+    isempty(errors) || throw(errors[minimum(keys(errors))])
+    results
+end
+
+function parallel(thunks)
+    values = collect(thunks)
+    for thunk in values
+        applicable(thunk) || error("parallel() expects zero-argument callables")
+    end
+    senpi_pool_map(values, thunk -> thunk())
+end
+
+function pipeline(items, stages...)
+    values = collect(items)
+    for stage in stages
+        isempty(values) && return values
+        applicable(stage, first(values)) || error("pipeline() stages must be callables")
+        values = senpi_pool_map(values, stage)
+    end
+    values
+end
+
+function log(message)
+    senpi_emit(Dict("type" => "log", "message" => string(message)))
+    nothing
+end
+
+function phase(title)
+    senpi_emit(Dict("type" => "phase", "title" => string(title)))
+    nothing
+end

package/src/kernels/jl/runner.jl

@@ -0,0 +1,327 @@
+# allow: SIZE_OK — parser, stream capture, bridge calls, and the persistent execution loop share Main globals.
+using Sockets
+
+const SENPI_ORIGINAL_STDOUT = stdout
+const SENPI_ORIGINAL_STDIN = stdin
+out_read, out_write = redirect_stdout()
+err_read, err_write = redirect_stderr()
+redirect_stdin(devnull)
+
+include("prelude.jl")
+
+const senpi_connection = Dict{String, Any}()
+const senpi_write_lock = ReentrantLock()
+global senpi_current_cell = nothing
+
+function senpi_escape(text::AbstractString)
+    out = IOBuffer()
+    for character in text
+        if character == '"'
+            Base.write(out, "\\\"")
+        elseif character == '\\'
+            Base.write(out, "\\\\")
+        elseif character == '\n'
+            Base.write(out, "\\n")
+        elseif character == '\r'
+            Base.write(out, "\\r")
+        elseif character == '\t'
+            Base.write(out, "\\t")
+        else
+            Base.write(out, character)
+        end
+    end
+    String(take!(out))
+end
+
+function senpi_json(value)
+    if value === nothing
+        return "null"
+    elseif value isa Bool
+        return value ? "true" : "false"
+    elseif value isa Number
+        return string(value)
+    elseif value isa AbstractString
+        return "\"" * senpi_escape(value) * "\""
+    elseif value isa AbstractDict
+        return "{" * join(["\"" * senpi_escape(string(key)) * "\":" * senpi_json(item) for (key, item) in value], ",") * "}"
+    elseif value isa AbstractVector || value isa Tuple
+        return "[" * join([senpi_json(item) for item in value], ",") * "]"
+    end
+    "\"" * senpi_escape(string(value)) * "\""
+end
+
+function senpi_json_parse(input::AbstractString)
+    characters = collect(input)
+    cursor = Ref(1)
+    length_value = length(characters)
+    function skip_space()
+        while cursor[] <= length_value && isspace(characters[cursor[]])
+            cursor[] += 1
+        end
+    end
+    function parse_string()
+        characters[cursor[]] == '"' || error("Expected JSON string")
+        cursor[] += 1
+        out = IOBuffer()
+        while cursor[] <= length_value
+            character = characters[cursor[]]
+            cursor[] += 1
+            character == '"' && return String(take!(out))
+            if character != '\\'
+                Base.write(out, character)
+                continue
+            end
+            cursor[] <= length_value || error("Unexpected JSON string escape")
+            escaped = characters[cursor[]]
+            cursor[] += 1
+            if escaped == 'u'
+                cursor[] + 3 <= length_value || error("Incomplete JSON unicode escape")
+                code = parse(Int, String(characters[cursor[]:cursor[] + 3]); base=16)
+                Base.write(out, Char(code))
+                cursor[] += 4
+            else
+                mapped = escaped == 'n' ? '\n' : escaped == 'r' ? '\r' : escaped == 't' ? '\t' : escaped == 'b' ? '\b' : escaped == 'f' ? '\f' : escaped
+                Base.write(out, mapped)
+            end
+        end
+        error("Unterminated JSON string")
+    end
+    function parse_value()
+        skip_space()
+        cursor[] <= length_value || error("Unexpected JSON end")
+        character = characters[cursor[]]
+        if character == '"'
+            return parse_string()
+        elseif character == '{'
+            cursor[] += 1
+            object_result = Dict{String, Any}()
+            skip_space()
+            if cursor[] <= length_value && characters[cursor[]] == '}'
+                cursor[] += 1
+                return object_result
+            end
+            while true
+                skip_space()
+                key = parse_string()
+                skip_space()
+                cursor[] <= length_value && characters[cursor[]] == ':' || error("Expected JSON object colon")
+                cursor[] += 1
+                object_result[key] = parse_value()
+                skip_space()
+                cursor[] <= length_value || error("Unexpected JSON object end")
+                characters[cursor[]] == '}' && (cursor[] += 1; return object_result)
+                characters[cursor[]] == ',' || error("Expected JSON object separator")
+                cursor[] += 1
+            end
+        elseif character == '['
+            cursor[] += 1
+            array_result = Any[]
+            skip_space()
+            if cursor[] <= length_value && characters[cursor[]] == ']'
+                cursor[] += 1
+                return array_result
+            end
+            while true
+                push!(array_result, parse_value())
+                skip_space()
+                cursor[] <= length_value || error("Unexpected JSON array end")
+                characters[cursor[]] == ']' && (cursor[] += 1; return array_result)
+                characters[cursor[]] == ',' || error("Expected JSON array separator")
+                cursor[] += 1
+            end
+        elseif startswith(String(characters[cursor[]:end]), "true")
+            cursor[] += 4
+            return true
+        elseif startswith(String(characters[cursor[]:end]), "false")
+            cursor[] += 5
+            return false
+        elseif startswith(String(characters[cursor[]:end]), "null")
+            cursor[] += 4
+            return nothing
+        end
+        start = cursor[]
+        while cursor[] <= length_value && characters[cursor[]] in ['-', '+', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+            cursor[] += 1
+        end
+        number = String(characters[start:cursor[] - 1])
+        integer = tryparse(Int, number)
+        integer === nothing || return integer
+        decimal = tryparse(Float64, number)
+        decimal === nothing && error("Invalid JSON value")
+        decimal
+    end
+    parsed_result = parse_value()
+    skip_space()
+    cursor[] > length_value || error("Trailing JSON data")
+    parsed_result
+end
+
+function senpi_emit(frame)
+    lock(senpi_write_lock) do
+        println(SENPI_ORIGINAL_STDOUT, senpi_json(frame))
+        flush(SENPI_ORIGINAL_STDOUT)
+    end
+    nothing
+end
+
+function senpi_emit_stream(stream::String, bytes::Vector{UInt8})
+    senpi_current_cell === nothing && return nothing
+    isempty(bytes) && return nothing
+    data = try
+        String(copy(bytes))
+    catch
+        repr(bytes)
+    end
+    senpi_emit(Dict("type" => "text", "stream" => stream, "data" => data))
+    nothing
+end
+
+function senpi_drain_stream(io, stream::String)
+    while true
+        bytes = readavailable(io)
+        if !isempty(bytes)
+            senpi_emit_stream(stream, bytes)
+        elseif eof(io)
+            return nothing
+        else
+            yield()
+            sleep(0.001)
+        end
+    end
+end
+
+@async senpi_drain_stream(out_read, "stdout")
+@async senpi_drain_stream(err_read, "stderr")
+
+function senpi_http_body(response::AbstractString)
+    parts = split(response, "\r\n\r\n"; limit=2)
+    length(parts) == 2 || return response
+    headers, body = parts
+    occursin("transfer-encoding: chunked", lowercase(headers)) || return body
+    bytes = collect(codeunits(body))
+    output = UInt8[]
+    cursor = 1
+    while cursor <= length(bytes)
+        header_end = nothing
+        for index in cursor:length(bytes) - 1
+            if bytes[index] == 0x0d && bytes[index + 1] == 0x0a
+                header_end = index
+                break
+            end
+        end
+        header_end === nothing && error("Invalid chunked bridge response")
+        chunk_size = parse(Int, split(String(bytes[cursor:header_end - 1]), ";"; limit=2)[1]; base=16)
+        cursor = header_end + 2
+        chunk_size == 0 && break
+        cursor + chunk_size - 1 <= length(bytes) || error("Truncated chunked bridge response")
+        append!(output, bytes[cursor:cursor + chunk_size - 1])
+        cursor += chunk_size + 2
+    end
+    String(output)
+end
+
+function senpi_bridge_request(path::String, payload)
+    port = get(senpi_connection, "port", nothing)
+    token = get(senpi_connection, "token", nothing)
+    port isa Integer && token isa AbstractString || error("Julia tool bridge is not initialized")
+    body = senpi_json(payload)
+    socket = connect(ip"127.0.0.1", port)
+    try
+        request = join([
+            "POST " * path * " HTTP/1.1",
+            "Host: 127.0.0.1",
+            "Authorization: Bearer " * string(token),
+            "Content-Type: application/json",
+            "Content-Length: " * string(sizeof(body)),
+            "Connection: close",
+            "",
+            body,
+        ], "\r\n")
+        Base.write(socket, request)
+        flush(socket)
+        response = Base.read(socket, String)
+        parsed = senpi_json_parse(senpi_http_body(response))
+        parsed isa AbstractDict || error("Bridge returned invalid JSON")
+        get(parsed, "ok", false) === true && return get(parsed, "value", nothing)
+        failure = get(parsed, "error", parsed)
+        error(failure isa AbstractDict ? string(get(failure, "message", failure)) : string(failure))
+    finally
+        close(socket)
+    end
+end
+
+function senpi_call_tool(name::String, arguments)
+    senpi_bridge_request("/call", Dict("callId" => "jl-" * string(time_ns()), "toolName" => name, "args" => arguments))
+end
+
+function senpi_completion(prompt::String, options)
+    senpi_bridge_request("/completion", Dict("prompt" => prompt, "opts" => options))
+end
+
+function senpi_error(error)
+    message = sprint(showerror, error)
+    Dict("name" => string(typeof(error)), "message" => message)
+end
+
+function senpi_should_display_result(parsed)
+    if parsed isa Expr && parsed.head === :block && !isempty(parsed.args)
+        last = parsed.args[end]
+        if last isa Expr && last.head in [Symbol("="), :function, :struct, :using, :import, :const, :global, :local, :macro]
+            return false
+        end
+    end
+    true
+end
+
+function senpi_set_connection(value)
+    value isa AbstractDict || error("missing bridge connection")
+    empty!(senpi_connection)
+    for (key, item) in value
+        senpi_connection[string(key)] = item
+    end
+end
+
+function senpi_run_cell(message)
+    cell_id = string(get(message, "cellId", ""))
+    code = string(get(message, "code", ""))
+    started = time()
+    global senpi_current_cell = cell_id
+    try
+        parsed = Meta.parse("begin\n" * code * "\nend")
+        if parsed isa Expr && parsed.head === :error
+            error(string(parsed.args[1]))
+        end
+        value = Core.eval(Main, parsed)
+        flush(stdout)
+        flush(stderr)
+        yield()
+        frame = Dict{String, Any}("type" => "result", "cellId" => cell_id, "ok" => true, "durationMs" => round(Int, (time() - started) * 1000))
+        value !== nothing && senpi_should_display_result(parsed) && (frame["valueRepr"] = senpi_json(value))
+        senpi_emit(frame)
+    catch error
+        senpi_emit(Dict("type" => "result", "cellId" => cell_id, "ok" => false, "error" => senpi_error(error), "durationMs" => round(Int, (time() - started) * 1000)))
+    finally
+        global senpi_current_cell = nothing
+    end
+end
+
+while !eof(SENPI_ORIGINAL_STDIN)
+    line = readline(SENPI_ORIGINAL_STDIN)
+    isempty(line) && continue
+    try
+        message = senpi_json_parse(line)
+        message isa AbstractDict || error("Bridge frame must be an object")
+        kind = get(message, "type", nothing)
+        if kind == "init"
+            senpi_set_connection(get(message, "connection", nothing))
+            senpi_emit(Dict("type" => "ready"))
+        elseif kind == "run"
+            senpi_run_cell(message)
+        elseif kind == "close"
+            senpi_emit(Dict("type" => "closed"))
+            break
+        end
+    catch error
+        senpi_emit(Dict("type" => "init-failed", "error" => senpi_error(error)))
+    end
+end