soraacode 0.2.0 → 0.2.1

package/src/git/index.ts

@@ -1,348 +0,0 @@
-import { LayerNode } from "@soraacode/core/effect/layer-node"
-import { AppProcess } from "@soraacode/core/process"
-import { Effect, Layer, Context, Stream } from "effect"
-import { ChildProcess } from "effect/unstable/process"
-
-const cfg = [
-  "--no-optional-locks",
-  "-c",
-  "core.autocrlf=false",
-  "-c",
-  "core.fsmonitor=false",
-  "-c",
-  "core.longpaths=true",
-  "-c",
-  "core.symlinks=true",
-  "-c",
-  "core.quotepath=false",
-] as const
-
-const out = (result: { text(): string }) => result.text().trim()
-const nuls = (text: string) => text.split("\0").filter(Boolean)
-const fail = (err: unknown) =>
-  ({
-    exitCode: 1,
-    text: () => "",
-    stdout: Buffer.alloc(0),
-    stderr: Buffer.from(err instanceof Error ? err.message : String(err)),
-    truncated: false,
-  }) satisfies Result
-
-export type Kind = "added" | "deleted" | "modified"
-
-export type Base = {
-  readonly name: string
-  readonly ref: string
-}
-
-export type Item = {
-  readonly file: string
-  readonly code: string
-  readonly status: Kind
-}
-
-export type Stat = {
-  readonly file: string
-  readonly additions: number
-  readonly deletions: number
-}
-
-export type Patch = {
-  readonly text: string
-  readonly truncated: boolean
-}
-
-export interface PatchOptions {
-  readonly context?: number
-  readonly maxOutputBytes?: number
-}
-
-export interface Result {
-  readonly exitCode: number
-  readonly text: () => string
-  readonly stdout: Buffer
-  readonly stderr: Buffer
-  readonly truncated: boolean
-}
-
-export interface Options {
-  readonly cwd: string
-  readonly env?: Record<string, string>
-  readonly maxOutputBytes?: number
-  readonly stdin?: ChildProcess.CommandInput
-}
-
-export interface Interface {
-  readonly run: (args: string[], opts: Options) => Effect.Effect<Result>
-  readonly branch: (cwd: string) => Effect.Effect<string | undefined>
-  readonly prefix: (cwd: string) => Effect.Effect<string>
-  readonly defaultBranch: (cwd: string) => Effect.Effect<Base | undefined>
-  readonly hasHead: (cwd: string) => Effect.Effect<boolean>
-  readonly mergeBase: (cwd: string, base: string, head?: string) => Effect.Effect<string | undefined>
-  readonly show: (cwd: string, ref: string, file: string, prefix?: string) => Effect.Effect<string>
-  readonly status: (cwd: string) => Effect.Effect<Item[]>
-  readonly diff: (cwd: string, ref: string) => Effect.Effect<Item[]>
-  readonly stats: (cwd: string, ref: string) => Effect.Effect<Stat[]>
-  readonly patch: (cwd: string, ref: string, file: string, options?: PatchOptions) => Effect.Effect<Patch>
-  readonly patchAll: (cwd: string, ref: string, options?: PatchOptions) => Effect.Effect<Patch>
-  readonly patchUntracked: (cwd: string, file: string, options?: PatchOptions) => Effect.Effect<Patch>
-  readonly statUntracked: (cwd: string, file: string) => Effect.Effect<Stat | undefined>
-  readonly applyPatch: (cwd: string, patch: string) => Effect.Effect<Result>
-}
-
-const kind = (code: string): Kind => {
-  if (code === "??") return "added"
-  if (code.includes("U")) return "modified"
-  if (code.includes("A") && !code.includes("D")) return "added"
-  if (code.includes("D") && !code.includes("A")) return "deleted"
-  return "modified"
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Git") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const appProcess = yield* AppProcess.Service
-    const encoder = new TextEncoder()
-    const stdin = (text: string) => Stream.make(encoder.encode(text))
-
-    const run = Effect.fn("Git.run")(
-      function* (args: string[], opts: Options) {
-        const result = yield* appProcess.run(
-          ChildProcess.make("git", [...cfg, ...args], {
-            cwd: opts.cwd,
-            env: opts.env,
-            extendEnv: true,
-            stdin: opts.stdin ?? "ignore",
-            stdout: "pipe",
-            stderr: "pipe",
-          }),
-          { maxOutputBytes: opts.maxOutputBytes },
-        )
-        return {
-          exitCode: result.exitCode,
-          text: () => result.stdout.toString("utf8"),
-          stdout: result.stdout,
-          stderr: result.stderr,
-          truncated: result.stdoutTruncated || result.stderrTruncated,
-        } satisfies Result
-      },
-      Effect.catch((err) => Effect.succeed(fail(err))),
-    )
-
-    const text = Effect.fn("Git.text")(function* (args: string[], opts: Options) {
-      return (yield* run(args, opts)).text()
-    })
-
-    const lines = Effect.fn("Git.lines")(function* (args: string[], opts: Options) {
-      return (yield* text(args, opts))
-        .split(/\r?\n/)
-        .map((item) => item.trim())
-        .filter(Boolean)
-    })
-
-    const refs = Effect.fnUntraced(function* (cwd: string) {
-      return yield* lines(["for-each-ref", "--format=%(refname:short)", "refs/heads"], { cwd })
-    })
-
-    const configured = Effect.fnUntraced(function* (cwd: string, list: string[]) {
-      const result = yield* run(["config", "init.defaultBranch"], { cwd })
-      const name = out(result)
-      if (!name || !list.includes(name)) return
-      return { name, ref: name } satisfies Base
-    })
-
-    const primary = Effect.fnUntraced(function* (cwd: string) {
-      const list = yield* lines(["remote"], { cwd })
-      if (list.includes("origin")) return "origin"
-      if (list.length === 1) return list[0]
-      if (list.includes("upstream")) return "upstream"
-      return list[0]
-    })
-
-    const branch = Effect.fn("Git.branch")(function* (cwd: string) {
-      const result = yield* run(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd })
-      if (result.exitCode !== 0) return
-      const text = out(result)
-      return text || undefined
-    })
-
-    const prefix = Effect.fn("Git.prefix")(function* (cwd: string) {
-      const result = yield* run(["rev-parse", "--show-prefix"], { cwd })
-      if (result.exitCode !== 0) return ""
-      return out(result)
-    })
-
-    const defaultBranch = Effect.fn("Git.defaultBranch")(function* (cwd: string) {
-      const remote = yield* primary(cwd)
-      if (remote) {
-        const head = yield* run(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd })
-        if (head.exitCode === 0) {
-          const ref = out(head).replace(/^refs\/remotes\//, "")
-          const name = ref.startsWith(`${remote}/`) ? ref.slice(`${remote}/`.length) : ""
-          if (name) return { name, ref } satisfies Base
-        }
-      }
-
-      const list = yield* refs(cwd)
-      const next = yield* configured(cwd, list)
-      if (next) return next
-      if (list.includes("main")) return { name: "main", ref: "main" } satisfies Base
-      if (list.includes("master")) return { name: "master", ref: "master" } satisfies Base
-    })
-
-    const hasHead = Effect.fn("Git.hasHead")(function* (cwd: string) {
-      const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd })
-      return result.exitCode === 0
-    })
-
-    const mergeBase = Effect.fn("Git.mergeBase")(function* (cwd: string, base: string, head = "HEAD") {
-      const result = yield* run(["merge-base", base, head], { cwd })
-      if (result.exitCode !== 0) return
-      const text = out(result)
-      return text || undefined
-    })
-
-    const show = Effect.fn("Git.show")(function* (cwd: string, ref: string, file: string, prefix = "") {
-      const target = prefix ? `${prefix}${file}` : file
-      const result = yield* run(["show", `${ref}:${target}`], { cwd })
-      if (result.exitCode !== 0) return ""
-      if (result.stdout.includes(0)) return ""
-      return result.text()
-    })
-
-    const status = Effect.fn("Git.status")(function* (cwd: string) {
-      return nuls(
-        yield* text(["status", "--porcelain=v1", "--untracked-files=all", "--no-renames", "-z", "--", "."], {
-          cwd,
-        }),
-      ).flatMap((item) => {
-        const file = item.slice(3)
-        if (!file) return []
-        const code = item.slice(0, 2)
-        return [{ file, code, status: kind(code) } satisfies Item]
-      })
-    })
-
-    const diff = Effect.fn("Git.diff")(function* (cwd: string, ref: string) {
-      const list = nuls(
-        yield* text(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, "--", "."], { cwd }),
-      )
-      return list.flatMap((code, idx) => {
-        if (idx % 2 !== 0) return []
-        const file = list[idx + 1]
-        if (!code || !file) return []
-        return [{ file, code, status: kind(code) } satisfies Item]
-      })
-    })
-
-    const stats = Effect.fn("Git.stats")(function* (cwd: string, ref: string) {
-      return nuls(
-        yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, "--", "."], { cwd }),
-      ).flatMap((item) => {
-        const a = item.indexOf("\t")
-        const b = item.indexOf("\t", a + 1)
-        if (a === -1 || b === -1) return []
-        const file = item.slice(b + 1)
-        if (!file) return []
-        const adds = item.slice(0, a)
-        const dels = item.slice(a + 1, b)
-        const additions = adds === "-" ? 0 : Number.parseInt(adds || "0", 10)
-        const deletions = dels === "-" ? 0 : Number.parseInt(dels || "0", 10)
-        return [
-          {
-            file,
-            additions: Number.isFinite(additions) ? additions : 0,
-            deletions: Number.isFinite(deletions) ? deletions : 0,
-          } satisfies Stat,
-        ]
-      })
-    })
-
-    const patch = Effect.fn("Git.patch")(function* (cwd: string, ref: string, file: string, options?: PatchOptions) {
-      const result = yield* run(
-        ["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", file],
-        { cwd, maxOutputBytes: options?.maxOutputBytes },
-      )
-      return { text: result.truncated ? "" : result.text(), truncated: result.truncated } satisfies Patch
-    })
-
-    const patchAll = Effect.fn("Git.patchAll")(function* (cwd: string, ref: string, options?: PatchOptions) {
-      const result = yield* run(
-        ["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", "."],
-        { cwd, maxOutputBytes: options?.maxOutputBytes },
-      )
-      return { text: result.text(), truncated: result.truncated } satisfies Patch
-    })
-
-    const patchUntracked = Effect.fn("Git.patchUntracked")(function* (
-      cwd: string,
-      file: string,
-      options?: PatchOptions,
-    ) {
-      const result = yield* run(
-        [
-          "diff",
-          "--no-index",
-          "--patch",
-          "--no-ext-diff",
-          "--no-renames",
-          `--unified=${options?.context ?? 3}`,
-          "--",
-          "/dev/null",
-          file,
-        ],
-        { cwd, maxOutputBytes: options?.maxOutputBytes },
-      )
-      return { text: result.truncated ? "" : result.text(), truncated: result.truncated } satisfies Patch
-    })
-
-    const statUntracked = Effect.fn("Git.statUntracked")(function* (cwd: string, file: string) {
-      const result = yield* run(["diff", "--no-index", "--numstat", "--", "/dev/null", file], {
-        cwd,
-        maxOutputBytes: 4096,
-      })
-
-      if (result.truncated) return
-      const text = result.text()
-
-      const parts = text.split("\t")
-      if (parts.length < 2) return
-
-      const additions = parts[0] === "-" ? 0 : Number.parseInt(parts[0] || "0", 10)
-      const deletions = parts[1] === "-" ? 0 : Number.parseInt(parts[1] || "0", 10)
-      return {
-        file,
-        additions: Number.isFinite(additions) ? additions : 0,
-        deletions: Number.isFinite(deletions) ? deletions : 0,
-      } satisfies Stat
-    })
-
-    const applyPatch = Effect.fn("Git.applyPatch")(function* (cwd: string, patch: string) {
-      return yield* run(["apply", "-"], { cwd, stdin: stdin(patch) })
-    })
-
-    return Service.of({
-      run,
-      branch,
-      prefix,
-      defaultBranch,
-      hasHead,
-      mergeBase,
-      show,
-      status,
-      diff,
-      stats,
-      patch,
-      patchAll,
-      patchUntracked,
-      statUntracked,
-      applyPatch,
-    })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [AppProcess.node] })
-
-export * as Git from "."

package/src/id/id.ts

@@ -1,80 +0,0 @@
-import { randomBytes } from "crypto"
-
-const prefixes = {
-  job: "job",
-  event: "evt",
-  session: "ses",
-  message: "msg",
-  permission: "per",
-  question: "que",
-  part: "prt",
-  pty: "pty",
-  tool: "tool",
-  workspace: "wrk",
-} as const
-
-const LENGTH = 26
-
-// State for monotonic ID generation
-let lastTimestamp = 0
-let counter = 0
-
-export function ascending(prefix: keyof typeof prefixes, given?: string) {
-  return generateID(prefix, "ascending", given)
-}
-
-export function descending(prefix: keyof typeof prefixes, given?: string) {
-  return generateID(prefix, "descending", given)
-}
-
-function generateID(prefix: keyof typeof prefixes, direction: "descending" | "ascending", given?: string): string {
-  if (!given) {
-    return create(prefixes[prefix], direction)
-  }
-
-  if (!given.startsWith(prefixes[prefix])) {
-    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
-  }
-  return given
-}
-
-function randomBase62(length: number): string {
-  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-  let result = ""
-  const bytes = randomBytes(length)
-  for (let i = 0; i < length; i++) {
-    result += chars[bytes[i] % 62]
-  }
-  return result
-}
-
-export function create(prefix: string, direction: "descending" | "ascending", timestamp?: number): string {
-  const currentTimestamp = timestamp ?? Date.now()
-
-  if (currentTimestamp !== lastTimestamp) {
-    lastTimestamp = currentTimestamp
-    counter = 0
-  }
-  counter++
-
-  let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-  now = direction === "descending" ? ~now : now
-
-  const timeBytes = Buffer.alloc(6)
-  for (let i = 0; i < 6; i++) {
-    timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-  }
-
-  return prefix + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
-}
-
-/** Extract timestamp from an ascending ID. Does not work with descending IDs. */
-export function timestamp(id: string): number {
-  const prefix = id.split("_")[0]
-  const hex = id.slice(prefix.length + 1, prefix.length + 13)
-  const encoded = BigInt("0x" + hex)
-  return Number(encoded / BigInt(0x1000))
-}
-
-export * as Identifier from "./id"

package/src/ide/index.ts

@@ -1,54 +0,0 @@
-import { Schema } from "effect"
-import { NamedError } from "@soraacode/core/util/error"
-import { Process } from "@/util/process"
-import { IdeEvent } from "@soraacode/schema/ide-event"
-
-const SUPPORTED_IDES = [
-  { name: "Windsurf" as const, cmd: "windsurf" },
-  { name: "Visual Studio Code - Insiders" as const, cmd: "code-insiders" },
-  { name: "Visual Studio Code" as const, cmd: "code" },
-  { name: "Cursor" as const, cmd: "cursor" },
-  { name: "VSCodium" as const, cmd: "codium" },
-]
-
-export const Event = IdeEvent
-
-export const AlreadyInstalledError = NamedError.create("AlreadyInstalledError", {})
-
-export const InstallFailedError = NamedError.create("InstallFailedError", {
-  stderr: Schema.String,
-})
-
-export function ide() {
-  if (process.env["TERM_PROGRAM"] === "vscode") {
-    const v = process.env["GIT_ASKPASS"]
-    for (const ide of SUPPORTED_IDES) {
-      if (v?.includes(ide.name)) return ide.name
-    }
-  }
-  return "unknown"
-}
-
-export function alreadyInstalled() {
-  return process.env["OPENCODE_CALLER"] === "vscode" || process.env["OPENCODE_CALLER"] === "vscode-insiders"
-}
-
-export async function install(ide: (typeof SUPPORTED_IDES)[number]["name"]) {
-  const cmd = SUPPORTED_IDES.find((i) => i.name === ide)?.cmd
-  if (!cmd) throw new Error(`Unknown IDE: ${ide}`)
-
-  const p = await Process.run([cmd, "--install-extension", "sst-dev.opencode"], {
-    nothrow: true,
-  })
-  const stdout = p.stdout.toString()
-  const stderr = p.stderr.toString()
-
-  if (p.code !== 0) {
-    throw new InstallFailedError({ stderr })
-  }
-  if (stdout.includes("already installed")) {
-    throw new AlreadyInstalledError({})
-  }
-}
-
-export * as Ide from "."

package/src/image/image.ts

@@ -1,172 +0,0 @@
-import { LayerNode } from "@soraacode/core/effect/layer-node"
-import { Config } from "@/config/config"
-import { SessionV1 } from "@soraacode/core/v1/session"
-import type { MessageV2 } from "@/session/message-v2"
-import photonWasm from "@silvia-odwyer/photon-node/photon_rs_bg.wasm" with { type: "file" }
-import { Context, Effect, Layer, Schema } from "effect"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-const MAX_BASE64_BYTES = 5 * 1024 * 1024
-const MAX_WIDTH = 2000
-const MAX_HEIGHT = 2000
-const AUTO_RESIZE = true
-const JPEG_QUALITIES = [80, 85, 70, 55, 40]
-export class ResizerUnavailableError extends Schema.TaggedErrorClass<ResizerUnavailableError>()(
-  "ImageResizerUnavailableError",
-  {},
-) {
-  override get message() {
-    return "Image resizer is unavailable"
-  }
-}
-
-export class InvalidDataUrlError extends Schema.TaggedErrorClass<InvalidDataUrlError>()("ImageInvalidDataUrlError", {
-  url: Schema.String,
-}) {
-  override get message() {
-    return "Image URL must be a base64 data URL"
-  }
-}
-
-export class DecodeError extends Schema.TaggedErrorClass<DecodeError>()("ImageDecodeError", {}) {
-  override get message() {
-    return "Image could not be decoded"
-  }
-}
-
-export class SizeError extends Schema.TaggedErrorClass<SizeError>()("ImageSizeError", {
-  bytes: Schema.Number,
-  max: Schema.Number,
-  width: Schema.Number,
-  height: Schema.Number,
-  max_width: Schema.Number,
-  max_height: Schema.Number,
-}) {
-  override get message() {
-    return `Image ${this.width}x${this.height} with base64 size ${this.bytes} exceeds configured limits and could not be resized below ${this.max_width}x${this.max_height}/${this.max} bytes`
-  }
-}
-
-export type Error = ResizerUnavailableError | InvalidDataUrlError | DecodeError | SizeError
-
-export interface Interface {
-  readonly normalize: (input: SessionV1.FilePart) => Effect.Effect<SessionV1.FilePart, Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Image") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const loadPhoton = yield* Effect.cached(
-      Effect.sync(() => {
-        // Patched photon-node reads this during module init so Bun compiled binaries use the embedded wasm path.
-        ;(globalThis as typeof globalThis & { __OPENCODE_PHOTON_WASM_PATH?: string }).__OPENCODE_PHOTON_WASM_PATH =
-          path.isAbsolute(photonWasm) ? photonWasm : fileURLToPath(new URL(photonWasm, import.meta.url))
-      }).pipe(
-        Effect.andThen(() => Effect.tryPromise(() => import("@silvia-odwyer/photon-node"))),
-        Effect.tapError((error) => Effect.logWarning("failed to load photon", { error })),
-        Effect.mapError(() => new ResizerUnavailableError()),
-      ),
-    )
-
-    const normalize = Effect.fn("Image.normalize")(function* (input: SessionV1.FilePart) {
-      const image = (yield* config.get()).attachment?.image
-      const info = {
-        autoResize: image?.auto_resize ?? AUTO_RESIZE,
-        maxWidth: image?.max_width ?? MAX_WIDTH,
-        maxHeight: image?.max_height ?? MAX_HEIGHT,
-        maxBase64Bytes: image?.max_base64_bytes ?? MAX_BASE64_BYTES,
-      }
-      if (!input.url.startsWith("data:") || !input.url.includes(";base64,"))
-        return yield* new InvalidDataUrlError({ url: input.url })
-
-      const base64 = input.url.slice(input.url.indexOf(";base64,") + ";base64,".length)
-      const bytes = Buffer.byteLength(base64, "utf8")
-
-      const photon = yield* loadPhoton
-
-      const decoded = yield* Effect.try({
-        try: () => photon.PhotonImage.new_from_byteslice(Buffer.from(base64, "base64")),
-        catch: () => new DecodeError(),
-      }).pipe(Effect.tapError((error) => Effect.logWarning("failed to decode image", { error })))
-
-      try {
-        const originalWidth = decoded.get_width()
-        const originalHeight = decoded.get_height()
-        if (originalWidth <= info.maxWidth && originalHeight <= info.maxHeight && bytes <= info.maxBase64Bytes)
-          return input
-        if (!info.autoResize)
-          return yield* new SizeError({
-            bytes,
-            max: info.maxBase64Bytes,
-            width: originalWidth,
-            height: originalHeight,
-            max_width: info.maxWidth,
-            max_height: info.maxHeight,
-          })
-
-        const scale = Math.min(1, info.maxWidth / originalWidth, info.maxHeight / originalHeight)
-        for (const size of Array.from({ length: 32 }).reduce<Array<{ width: number; height: number }>>((acc) => {
-          const previous = acc.at(-1) ?? {
-            width: Math.max(1, Math.round(originalWidth * scale)),
-            height: Math.max(1, Math.round(originalHeight * scale)),
-          }
-          const next =
-            acc.length === 0
-              ? previous
-              : {
-                  width: previous.width === 1 ? 1 : Math.max(1, Math.floor(previous.width * 0.75)),
-                  height: previous.height === 1 ? 1 : Math.max(1, Math.floor(previous.height * 0.75)),
-                }
-          return acc.some((item) => item.width === next.width && item.height === next.height) ? acc : [...acc, next]
-        }, [])) {
-          const resized = photon.resize(decoded, size.width, size.height, photon.SamplingFilter.Lanczos3)
-          const candidate = [
-            { data: Buffer.from(resized.get_bytes()).toString("base64"), mime: "image/png" },
-            ...JPEG_QUALITIES.map((quality) => ({
-              data: Buffer.from(resized.get_bytes_jpeg(quality)).toString("base64"),
-              mime: "image/jpeg",
-            })),
-          ]
-            .map((item) => ({ ...item, bytes: Buffer.byteLength(item.data, "utf8") }))
-            .find((item) => item.bytes <= info.maxBase64Bytes)
-          resized.free()
-
-          if (candidate) {
-            yield* Effect.logInfo("using resized image", {
-              from_mime: input.mime,
-              to_mime: candidate.mime,
-              from: `${originalWidth}x${originalHeight}`,
-              to: `${size.width}x${size.height}`,
-            })
-            return {
-              ...input,
-              mime: candidate.mime,
-              url: `data:${candidate.mime};base64,${candidate.data}`,
-            }
-          }
-        }
-
-        return yield* new SizeError({
-          bytes,
-          max: info.maxBase64Bytes,
-          width: originalWidth,
-          height: originalHeight,
-          max_width: info.maxWidth,
-          max_height: info.maxHeight,
-        })
-      } finally {
-        decoded.free()
-      }
-    })
-
-    return Service.of({ normalize })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Config.node] })
-
-export * as Image from "./image"