@code-yeongyu/senpi 2026.7.11 → 2026.7.13

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/rb/prelude.rb

@@ -1,50 +1,170 @@
 require "base64"
+require "fileutils"
 require "json"
+require "uri"
+
+SENPI_RESERVED_AGENT_TOOL = "__agent__"
+SENPI_RESERVED_OUTPUT_TOOL = "__output__"
+SENPI_INTERNAL_URL = Regexp.new("\\A([a-z][a-z0-9+.\\-]*)://(.*)\\z", Regexp::IGNORECASE)
+
+def __senpi_status_enabled?
+  connection = $__senpi_connection
+  return true unless connection.is_a?(Hash)
+  connection["statusEvents"] != false
+end
+
+def __senpi_emit_status(op, fields = {}, force: false)
+  return unless force || __senpi_status_enabled?
+  __senpi_emit({ "type" => "status", "event" => { "op" => op }.merge(fields.transform_keys(&:to_s)) })
+end
+
+def __senpi_resolve_path(value)
+  raw = value.to_s
+  match = SENPI_INTERNAL_URL.match(raw)
+  return File.expand_path(raw) unless match
+
+  scheme = match[1].downcase
+  roots = $__senpi_connection.is_a?(Hash) ? $__senpi_connection["localRoots"] : nil
+  root = roots[scheme] if roots.is_a?(Hash)
+  raise "Protocol paths are not supported by this helper: #{raw}" unless root.is_a?(String) && !root.empty?
+
+  relative = URI::DEFAULT_PARSER.unescape(match[2].tr("\\", "/"))
+  root_path = File.expand_path(root)
+  return root_path if relative.empty?
+  if relative.start_with?("/") || relative.split("/").include?("..")
+    raise "Unsafe #{scheme}:// path (absolute or traversal): #{raw}"
+  end
+
+  resolved = File.expand_path(relative, root_path)
+  unless resolved == root_path || resolved.start_with?(root_path + File::SEPARATOR)
+    raise "#{scheme}:// path escapes its root: #{raw}"
+  end
+  resolved
+end
+
+def __senpi_display_payload(value)
+  if value.is_a?(Hash)
+    kind = value["type"] || value[:type]
+    text_value = value["text"] || value[:text]
+    return ["text/markdown", text_value.to_s] if kind == "markdown" && !text_value.nil?
+    return ["image/png", value["data"].to_s] if kind == "image" && value["mimeType"] == "image/png"
+    return ["image/jpeg", value["data"].to_s] if kind == "image" && value["mimeType"] == "image/jpeg"
+    return ["application/json", JSON.generate(value)]
+  end
+  return ["application/json", JSON.generate(value)] if value.is_a?(Array)
+  ["text/plain", value.to_s]
+end
 
 def display(value)
-  payload = Base64.strict_encode64(JSON.generate(value))
-  __senpi_emit({ "type" => "display", "mimeType" => "application/json", "dataBase64" => payload })
+  mime_type, payload = __senpi_display_payload(value)
+  data_base64 = mime_type.start_with?("image/") ? payload : Base64.strict_encode64(payload)
+  __senpi_emit({ "type" => "display", "mimeType" => mime_type, "dataBase64" => data_base64 })
   nil
 end
 
-def print(*values)
-  __senpi_emit({ "type" => "text", "stream" => "stdout", "data" => values.join })
+def display_image(base64, mime_type: "image/png")
+  __senpi_emit({ "type" => "display", "mimeType" => mime_type.to_s, "dataBase64" => base64.to_s })
+  nil
+end
+
+def text(data)
+  __senpi_emit({ "type" => "text", "stream" => "stdout", "data" => data.to_s })
   nil
 end
 
-def read(path)
-  File.read(path.to_s)
+def print(*values)
+  text(values.join)
+end
+
+def read(path, offset = 1, limit = nil)
+  resolved = __senpi_resolve_path(path)
+  data = File.read(resolved, encoding: Encoding::UTF_8)
+  if offset > 1 || !limit.nil?
+    lines = data.lines
+    start = [offset.to_i - 1, 0].max
+    data = lines[start, limit || lines.length].to_a.join
+  end
+  __senpi_emit_status("read", { "path" => resolved, "chars" => data.length, "preview" => data[0, 500].to_s })
+  data
 end
 
 def write(path, content)
-  File.write(path.to_s, content.to_s)
-  path.to_s
+  resolved = __senpi_resolve_path(path)
+  FileUtils.mkdir_p(File.dirname(resolved))
+  data = content.to_s
+  File.write(resolved, data)
+  __senpi_emit_status("write", { "path" => resolved, "chars" => data.length })
+  resolved
 end
 
 def env(key = nil, value = nil)
-  return ENV.to_h if key.nil?
+  if key.nil?
+    entries = ENV.to_h.sort.to_h
+    __senpi_emit_status("env", { "count" => entries.length, "keys" => entries.keys.first(20) })
+    return entries
+  end
+
+  name = key.to_s
   if value.nil?
-    ENV[key.to_s]
-  else
-    ENV[key.to_s] = value.to_s
+    resolved = ENV[name]
+    __senpi_emit_status("env", { "key" => name, "value" => resolved, "action" => "get" })
+    return resolved
   end
+
+  resolved = value.to_s
+  ENV[name] = resolved
+  __senpi_emit_status("env", { "key" => name, "value" => resolved, "action" => "set" })
+  resolved
 end
 
-def log(message)
-  __senpi_emit({ "type" => "log", "message" => message.to_s })
-  nil
+def __senpi_bridge_request(path, payload)
+  connection = $__senpi_connection
+  raise "Ruby tool bridge is not initialized" unless connection.is_a?(Hash)
+  port = connection["port"]
+  token = connection["token"]
+  raise "Ruby tool bridge is not initialized" unless port.is_a?(Integer) && token.is_a?(String)
+
+  uri = URI("http://127.0.0.1:#{port}#{path}")
+  request = Net::HTTP::Post.new(uri)
+  request["authorization"] = "Bearer #{token}"
+  request["content-type"] = "application/json"
+  request.body = JSON.generate(payload)
+  __senpi_emit_status("timeout-pause", force: true)
+  begin
+    response = Net::HTTP.start(uri.hostname, uri.port, open_timeout: 10, read_timeout: 60) { |http| http.request(request) }
+  ensure
+    __senpi_emit_status("timeout-resume", force: true)
+  end
+  body = JSON.parse(response.body.to_s)
+  return body["value"] if body.is_a?(Hash) && body["ok"] == true
+
+  error = body.is_a?(Hash) ? body["error"] : body
+  raise(error.is_a?(Hash) ? error["message"].to_s : error.to_s)
 end
 
-def phase(title)
-  __senpi_emit({ "type" => "phase", "title" => title.to_s })
-  nil
+def __senpi_call_tool(name, args)
+  __senpi_bridge_request("/call", { "callId" => "rb-#{Process.pid}-#{rand(1_000_000)}", "toolName" => name, "args" => args })
+end
+
+class SenpiToolCallable
+  def initialize(name)
+    @name = name
+  end
+
+  def call(args = nil, **kwargs)
+    merged = args.nil? ? {} : args.is_a?(Hash) ? args.transform_keys(&:to_s) : raise(ArgumentError, "tool.#{@name}(...) expects a Hash of arguments")
+    kwargs.each { |key, value| merged[key.to_s] = value }
+    __senpi_call_tool(@name, merged)
+  end
 end
 
 class SenpiToolProxy < BasicObject
   def method_missing(name, args = nil, **kwargs)
-    merged = args.is_a?(::Hash) ? args.transform_keys(&:to_s) : {}
-    kwargs.each { |key, value| merged[key.to_s] = value }
-    ::Object.__send__(:__senpi_call_tool, name.to_s, merged)
+    ::SenpiToolCallable.new(name.to_s).call(args, **kwargs)
+  end
+
+  def [](name)
+    ::SenpiToolCallable.new(name.to_s)
   end
 
   def respond_to_missing?(_name, _private = false)
@@ -55,3 +175,96 @@ end
 def tool
   $__senpi_tool_proxy ||= SenpiToolProxy.new
 end
+
+def completion(prompt, model: "default", system: nil, schema: nil, **kwargs)
+  options = { "model" => model }.merge(kwargs.transform_keys(&:to_s))
+  options["system"] = system unless system.nil?
+  options["schema"] = schema unless schema.nil?
+  result = __senpi_bridge_request("/completion", { "prompt" => prompt.to_s, "opts" => options })
+  return result unless result.is_a?(Hash)
+  return result["value"] if result.key?("value")
+
+  result.fetch("text", result)
+end
+
+def output(*ids, format: "raw", offset: nil, limit: nil)
+  raise ArgumentError, "At least one output ID is required" if ids.empty?
+  raise ArgumentError, "output() format must be 'raw' or 'tail'" unless ["raw", "tail"].include?(format)
+  args = { "ids" => ids.map(&:to_s), "format" => format }
+  args["offset"] = offset unless offset.nil?
+  args["limit"] = limit unless limit.nil?
+  __senpi_call_tool(SENPI_RESERVED_OUTPUT_TOOL, args)
+end
+
+def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated: nil, apply: nil, merge: nil, handle: false)
+  args = { "prompt" => prompt.to_s, "agent" => agent }
+  { "model" => model, "label" => label, "schema" => schema, "isolated" => isolated, "apply" => apply, "merge" => merge }.each do |key, value|
+    args[key] = value unless value.nil?
+  end
+  args["handle"] = true if handle
+  response = __senpi_call_tool(SENPI_RESERVED_AGENT_TOOL, args)
+  record = response.is_a?(Hash) ? response : {}
+  text_value = record.fetch("text", response)
+  result = schema.nil? ? text_value : record.key?("data") ? record["data"] : JSON.parse(text_value.to_s)
+  return result unless handle
+  { "text" => text_value, "output" => text_value, "handle" => record["handle"] || (record["id"] && "agent://#{record["id"]}"), "id" => record["id"], "agent" => record.fetch("agent", agent) }.tap do |node|
+    node["data"] = result unless schema.nil?
+  end
+end
+
+def __senpi_pool_map(items)
+  values = items.to_a
+  return [] if values.empty?
+  connection = $__senpi_connection
+  configured_width = connection.is_a?(Hash) ? connection["parallelPoolWidth"] : nil
+  width = configured_width.is_a?(Numeric) ? configured_width.to_i : 4
+  workers = [[width, 1].max, values.length].min
+  results = Array.new(values.length)
+  failures = {}
+  failure_mutex = Mutex.new
+  queue = Queue.new
+  values.each_index { |index| queue << index }
+  threads = workers.times.map do
+    Thread.new do
+      loop do
+        index = queue.pop(true) rescue nil
+        break if index.nil?
+        begin
+          results[index] = yield(values[index])
+        rescue Exception => error
+          failure_mutex.synchronize { failures[index] = error }
+        end
+      end
+    end
+  end
+  threads.each(&:join)
+  raise failures[failures.keys.min] unless failures.empty?
+  results
+end
+
+def parallel(thunks)
+  values = thunks.to_a
+  values.each do |thunk|
+    raise TypeError, "parallel() expects an iterable of zero-arg callables" unless thunk.respond_to?(:call)
+  end
+  __senpi_pool_map(values) { |thunk| thunk.call }
+end
+
+def pipeline(items, *stages)
+  values = items.to_a
+  stages.each do |stage|
+    raise TypeError, "pipeline() stages must be callables" unless stage.respond_to?(:call)
+    values = __senpi_pool_map(values) { |value| stage.call(value) }
+  end
+  values
+end
+
+def log(message)
+  __senpi_emit({ "type" => "log", "message" => message.to_s })
+  nil
+end
+
+def phase(title)
+  __senpi_emit({ "type" => "phase", "title" => title.to_s })
+  nil
+end

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/rb/runner.rb

@@ -1,92 +1,193 @@
 require "json"
 require "net/http"
-require "stringio"
 require "uri"
-require_relative "prelude"
 
 $__senpi_binding = TOPLEVEL_BINDING
-$__senpi_mutex = Mutex.new
+$__senpi_frame_mutex = Mutex.new
 $__senpi_current_cell = nil
+$__senpi_capture_cell = nil
 $__senpi_connection = nil
+$__senpi_frame_io = STDOUT.dup
+$__senpi_frame_io.sync = true
+
+begin
+  stdout_read, stdout_write = IO.pipe
+  STDOUT.reopen(stdout_write)
+  STDOUT.sync = true
+  stdout_write.close
+  $__senpi_stdout_capture = stdout_read
+rescue StandardError
+  $__senpi_stdout_capture = nil
+end
+
+begin
+  stderr_read, stderr_write = IO.pipe
+  STDERR.reopen(stderr_write)
+  STDERR.sync = true
+  stderr_write.close
+  $__senpi_stderr_capture = stderr_read
+rescue StandardError
+  $__senpi_stderr_capture = nil
+end
+
+begin
+  $__senpi_protocol_stdin = STDIN.dup
+  STDIN.reopen(File.open(File::NULL, "r"))
+rescue StandardError
+  $__senpi_protocol_stdin = STDIN
+end
 
 def __senpi_emit(frame)
-  STDOUT.write(JSON.generate(frame))
-  STDOUT.write("\n")
-  STDOUT.flush
+  line = JSON.generate(frame)
+  $__senpi_frame_mutex.synchronize do
+    $__senpi_frame_io.write(line)
+    $__senpi_frame_io.write("\n")
+    $__senpi_frame_io.flush
+  end
+rescue StandardError
+  nil
 end
 
 def __senpi_error(error)
-  { "name" => error.class.name, "message" => error.message, "stack" => error.backtrace&.join("\n") }
+  { "name" => error.class.name, "message" => error.message.to_s, "stack" => error.backtrace&.join("\n") }
+end
+
+def __senpi_emit_stream(stream, data)
+  return if data.nil? || data.empty? || $__senpi_capture_cell.nil?
+  __senpi_emit({ "type" => "text", "stream" => stream, "data" => data })
+end
+
+class SenpiStreamProxy
+  def initialize(stream)
+    @stream = stream
+  end
+
+  def write(*values)
+    data = values.join
+    __senpi_emit_stream(@stream, data)
+    data.bytesize
+  end
+
+  def print(*values)
+    write(*values)
+    nil
+  end
+
+  def puts(*values)
+    values = [""] if values.empty?
+    values.each { |value| write(value.to_s.end_with?("\n") ? value.to_s : "#{value}\n") }
+    nil
+  end
+
+  def printf(format, *values)
+    write(Kernel.format(format, *values))
+    nil
+  end
+
+  def flush
+    self
+  end
+
+  def sync
+    true
+  end
+
+  def sync=(_value)
+    true
+  end
+
+  def tty?
+    false
+  end
 end
 
-def __senpi_call_tool(name, args)
-  connection = $__senpi_connection
-  raise "Ruby tool bridge is not initialized" unless connection.is_a?(Hash)
-  port = connection["port"]
-  token = connection["token"]
-  raise "Ruby tool bridge is not initialized" unless port.is_a?(Integer) && token.is_a?(String)
-
-  call_id = "#{Time.now.to_i}-#{rand(1_000_000)}"
-  uri = URI("http://127.0.0.1:#{port}/call")
-  request = Net::HTTP::Post.new(uri)
-  request["authorization"] = "Bearer #{token}"
-  request["content-type"] = "application/json"
-  request.body = JSON.generate({ "callId" => call_id, "toolName" => name, "args" => args })
-  response = Net::HTTP.start(uri.hostname, uri.port, read_timeout: 60) { |http| http.request(request) }
-  body = JSON.parse(response.body.to_s)
-  return body["value"] if body.is_a?(Hash) && body["ok"] == true
-
-  error = body.is_a?(Hash) ? body["error"] : body
-  if error.is_a?(Hash)
-    raise error["message"].to_s
+def __senpi_start_capture(io, stream)
+  return if io.nil?
+  Thread.new do
+    loop do
+      data = io.readpartial(65_536)
+      __senpi_emit_stream(stream, data)
+    rescue EOFError, IOError, Errno::EBADF
+      break
+    end
   end
-  raise error.to_s
 end
 
-# Capture the cell's $stdout writes (puts/print) and emit them as `text` frames.
-# $stdout is redirected to a buffer during eval so user output never contaminates
-# the JSONL protocol channel, which __senpi_emit writes to via the STDOUT constant
-# (the STDOUT constant is unaffected by reassigning the $stdout global).
+def __senpi_value_repr(value)
+  JSON.generate(value)
+rescue JSON::GeneratorError
+  value.inspect
+end
+
+SENPI_NON_DISPLAY_NODES = %i[
+  LASGN IASGN GASGN CVASGN DASGN OP_ASGN OP_CDECL CDECL MASGN CASGN
+  DEFN DEFS CLASS MODULE SCLASS ALIAS UNDEF
+].freeze
+
+def __senpi_ast_last(node)
+  return nil unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+  case node.type
+  when :SCOPE
+    __senpi_ast_last(node.children[2])
+  when :BLOCK
+    children = node.children.compact
+    children.empty? ? nil : __senpi_ast_last(children.last)
+  else
+    node
+  end
+end
+
+def __senpi_should_display_result?(source)
+  return true unless defined?(RubyVM::AbstractSyntaxTree)
+  node = RubyVM::AbstractSyntaxTree.parse(source)
+  last = __senpi_ast_last(node)
+  return true if last.nil?
+  !SENPI_NON_DISPLAY_NODES.include?(last.type)
+rescue StandardError, SyntaxError
+  true
+end
+
+require_relative "prelude"
+
+$stdout = SenpiStreamProxy.new("stdout")
+$stderr = SenpiStreamProxy.new("stderr")
+__senpi_start_capture($__senpi_stdout_capture, "stdout")
+__senpi_start_capture($__senpi_stderr_capture, "stderr")
+
 def __senpi_run_cell(message)
   started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  $__senpi_current_cell = message["cellId"]
-  captured = StringIO.new
-  previous_stdout = $stdout
-  $stdout = captured
+  cell_id = message["cellId"].to_s
+  $__senpi_current_cell = cell_id
+  $__senpi_capture_cell = cell_id
   begin
-    value = eval(message["code"].to_s, $__senpi_binding, "(senpi-rb)")
-    $stdout = previous_stdout
-    __senpi_flush_stdout(captured)
+    source = message["code"].to_s
+    value = eval(source, $__senpi_binding, "(senpi-rb)")
+    STDOUT.flush
+    STDERR.flush
+    Thread.pass
     frame = {
       "type" => "result",
-      "cellId" => message["cellId"],
+      "cellId" => cell_id,
       "ok" => true,
       "durationMs" => ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round,
     }
-    frame["valueRepr"] = JSON.generate(value) unless value.nil?
+    frame["valueRepr"] = __senpi_value_repr(value) if !value.nil? && __senpi_should_display_result?(source)
     __senpi_emit(frame)
   rescue Exception => error
-    $stdout = previous_stdout
-    __senpi_flush_stdout(captured)
     __senpi_emit({
       "type" => "result",
-      "cellId" => message["cellId"],
+      "cellId" => cell_id,
       "ok" => false,
       "error" => __senpi_error(error),
       "durationMs" => ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round,
     })
   ensure
-    $stdout = previous_stdout
+    $__senpi_capture_cell = nil
     $__senpi_current_cell = nil
   end
 end
 
-def __senpi_flush_stdout(captured)
-  data = captured.string
-  __senpi_emit({ "type" => "text", "stream" => "stdout", "data" => data }) unless data.empty?
-end
-
-STDIN.each_line do |line|
+$__senpi_protocol_stdin.each_line do |line|
   message = JSON.parse(line)
   case message["type"]
   when "init"
@@ -98,4 +199,6 @@ STDIN.each_line do |line|
     __senpi_emit({ "type" => "closed" })
     exit 0
   end
+rescue JSON::ParserError => error
+  __senpi_emit({ "type" => "init-failed", "error" => __senpi_error(error) })
 end

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-queue.ts

@@ -84,6 +84,7 @@ export class SubprocessRunQueue {
 			case "display":
 			case "log":
 			case "phase":
+			case "status":
 				if (this.#active) onMessage?.(message);
 				return false;
 			case "ready":

package/node_modules/@code-yeongyu/senpi-codemode/src/output/output-meta.ts

@@ -0,0 +1,89 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export interface SessionArtifactsDir {
+	readonly dir: string;
+	readonly temp: boolean;
+}
+
+export function formatMiddleElisionMarker(elidedLines: number, elidedBytes: number): string {
+	return elidedLines <= 1 ? `[…${elidedBytes}B elided…]` : `[…${elidedLines}ln elided…]`;
+}
+
+export function artifactNotice(path: string): string {
+	return `[Full output: ${path}]`;
+}
+
+export function resolveSessionArtifactsDir(sessionFile: string | undefined): SessionArtifactsDir {
+	const temp = sessionFile === undefined;
+	const dir =
+		sessionFile === undefined
+			? join(tmpdir(), `senpi-codemode-${randomBytes(8).toString("hex")}`)
+			: `${sessionFile.endsWith(".jsonl") ? sessionFile.slice(0, -6) : sessionFile}-artifacts`;
+	mkdirSync(dir, { recursive: true });
+	return { dir, temp };
+}
+
+export interface TruncationMeta {
+	readonly direction: "head" | "tail" | "middle";
+	readonly truncatedBy: "lines" | "bytes" | "middle";
+	readonly totalLines: number;
+	readonly totalBytes: number;
+	readonly outputLines: number;
+	readonly outputBytes: number;
+	readonly maxBytes?: number;
+	readonly shownRange?: { readonly start: number; readonly end: number };
+	readonly headRange?: { readonly start: number; readonly end: number };
+	readonly tailRange?: { readonly start: number; readonly end: number };
+	readonly elidedBytes?: number;
+	readonly elidedLines?: number;
+	/** Plain absolute artifact path; retained under the upstream field name. */
+	readonly artifactId?: string;
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function assertNever(value: never): never {
+	throw new TypeError(`Unhandled truncation direction: ${String(value)}`);
+}
+
+export function formatTruncationWarning(meta: TruncationMeta | undefined): string | null {
+	if (meta === undefined) return null;
+	let message: string;
+	switch (meta.direction) {
+		case "middle": {
+			const elidedLines = meta.elidedLines ?? Math.max(0, meta.totalLines - meta.outputLines);
+			const elidedBytes = meta.elidedBytes ?? Math.max(0, meta.totalBytes - meta.outputBytes);
+			message =
+				meta.headRange !== undefined && meta.tailRange !== undefined
+					? `Showing lines ${meta.headRange.start}-${meta.headRange.end} and ${meta.tailRange.start}-${meta.tailRange.end} of ${meta.totalLines}; ${elidedLines} middle line${elidedLines === 1 ? "" : "s"} (${formatBytes(elidedBytes)}) elided`
+					: `Showing ${meta.outputLines} of ${meta.totalLines} lines; middle elided`;
+			break;
+		}
+		case "head":
+		case "tail":
+			message =
+				meta.shownRange !== undefined && meta.shownRange.end >= meta.shownRange.start
+					? `Showing lines ${meta.shownRange.start}-${meta.shownRange.end} of ${meta.totalLines}`
+					: `Showing ${meta.outputLines} of ${meta.totalLines} lines`;
+			if (meta.truncatedBy === "bytes") message += ` (${formatBytes(meta.maxBytes ?? meta.outputBytes)} limit)`;
+			break;
+		default:
+			return assertNever(meta.direction);
+	}
+	if (meta.artifactId !== undefined) message += `. Full output: ${meta.artifactId}`;
+	return `[${message}]`;
+}
+
+export function stripOutputNotice(text: string, meta: TruncationMeta | undefined): string {
+	const notice = formatTruncationWarning(meta);
+	if (notice === null) return text;
+	const trimmed = text.trimEnd();
+	return trimmed.endsWith(notice) ? trimmed.slice(0, -notice.length).trimEnd() : text;
+}