rird 2.1.231 → 2.3.0

package/src/session/summary.ts

@@ -0,0 +1,209 @@
+import { Provider } from "@/provider/provider"
+
+import { fn } from "@/util/fn"
+import z from "zod"
+import { Session } from "."
+
+import { MessageV2 } from "./message-v2"
+import { Identifier } from "@/id/id"
+import { Snapshot } from "@/snapshot"
+
+import { Log } from "@/util/log"
+import path from "path"
+import { Instance } from "@/project/instance"
+import { Storage } from "@/storage/storage"
+import { Bus } from "@/bus"
+
+import { LLM } from "./llm"
+import { Agent } from "@/agent/agent"
+
+export namespace SessionSummary {
+  const log = Log.create({ service: "session.summary" })
+
+  export const summarize = fn(
+    z.object({
+      sessionID: z.string(),
+      messageID: z.string(),
+    }),
+    async (input) => {
+      const all = await Session.messages({ sessionID: input.sessionID })
+      await Promise.all([
+        summarizeSession({ sessionID: input.sessionID, messages: all }),
+        summarizeMessage({ messageID: input.messageID, messages: all }),
+      ])
+    },
+  )
+
+  async function summarizeSession(input: { sessionID: string; messages: MessageV2.WithParts[] }) {
+    const files = new Set(
+      input.messages
+        .flatMap((x) => x.parts)
+        .filter((x) => x.type === "patch")
+        .flatMap((x) => x.files)
+        .map((x) => path.relative(Instance.worktree, x)),
+    )
+    const diffs = await computeDiff({ messages: input.messages }).then((x) =>
+      x.filter((x) => {
+        return files.has(x.file)
+      }),
+    )
+    await Session.update(input.sessionID, (draft) => {
+      draft.summary = {
+        additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+        deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+        files: diffs.length,
+      }
+    })
+    await Storage.write(["session_diff", input.sessionID], diffs)
+    Bus.publish(Session.Event.Diff, {
+      sessionID: input.sessionID,
+      diff: diffs,
+    })
+  }
+
+  async function summarizeMessage(input: { messageID: string; messages: MessageV2.WithParts[] }) {
+    const messages = input.messages.filter(
+      (m) => m.info.id === input.messageID || (m.info.role === "assistant" && m.info.parentID === input.messageID),
+    )
+    const msgWithParts = messages.find((m) => m.info.id === input.messageID)!
+    const userMsg = msgWithParts.info as MessageV2.User
+    const diffs = await computeDiff({ messages })
+    userMsg.summary = {
+      ...userMsg.summary,
+      diffs,
+    }
+    await Session.updateMessage(userMsg)
+
+    const assistantMsg = messages.find((m) => m.info.role === "assistant")!.info as MessageV2.Assistant
+    const small = await (async () => {
+      try {
+        return (
+          (await Provider.getSmallModel(assistantMsg.providerID)) ??
+          (await Provider.getModel(assistantMsg.providerID, assistantMsg.modelID))
+        )
+      } catch {}
+      const fallback = await Provider.defaultModel()
+      return await Provider.getModel(fallback.providerID, fallback.modelID)
+    })()
+
+    const textPart = msgWithParts.parts.find((p) => p.type === "text" && !p.synthetic) as MessageV2.TextPart
+    if (textPart && !userMsg.summary?.title) {
+      /* DISABLED FOR TESTING
+      const agent = await Agent.get("title")
+      const stream = await LLM.stream({
+        agent,
+        user: userMsg,
+        tools: {},
+        model: agent.model ? await Provider.getModel(agent.model.providerID, agent.model.modelID) : small,
+        small: true,
+        messages: [
+          {
+            role: "user" as const,
+            content: `
+              The following is the text to summarize:
+              <text>
+              ${textPart?.text ?? ""}
+              </text>
+            `,
+          },
+        ],
+        abort: new AbortController().signal,
+        sessionID: userMsg.sessionID,
+        system: [],
+        retries: 3,
+      })
+      const result = await stream.text
+      log.info("title", { title: result })
+      userMsg.summary.title = result
+      await Session.updateMessage(userMsg)
+      */
+    }
+
+    if (
+      messages.some(
+        (m) =>
+          m.info.role === "assistant" && m.parts.some((p) => p.type === "step-finish" && p.reason !== "tool-calls"),
+      )
+    ) {
+      if (diffs.length > 0) {
+        for (const msg of messages) {
+          for (const part of msg.parts) {
+            if (part.type === "tool" && part.state.status === "completed") {
+              part.state.output = "[TOOL OUTPUT PRUNED]"
+            }
+          }
+        }
+        const summaryAgent = await Agent.get("summary")
+        const summaryModel = await (async () => {
+          if (!summaryAgent.model) return undefined
+          try {
+            return await Provider.getModel(summaryAgent.model.providerID, summaryAgent.model.modelID)
+          } catch {}
+          const fallback = await Provider.defaultModel()
+          return await Provider.getModel(fallback.providerID, fallback.modelID)
+        })()
+        const stream = await LLM.stream({
+          agent: summaryAgent,
+          user: userMsg,
+          tools: {},
+          model: summaryModel ?? small,
+          small: true,
+          messages: [
+            ...MessageV2.toModelMessage(messages, { sessionID: userMsg.sessionID }),
+            {
+              role: "user" as const,
+              content: `Summarize the above conversation according to your system prompts.`,
+            },
+          ],
+          abort: new AbortController().signal,
+          sessionID: userMsg.sessionID,
+          system: [],
+          retries: 3,
+        })
+        const result = await stream.text
+        if (result) {
+          userMsg.summary.body = result
+        }
+      }
+      await Session.updateMessage(userMsg)
+    }
+  }
+
+  export const diff = fn(
+    z.object({
+      sessionID: Identifier.schema("session"),
+      messageID: Identifier.schema("message").optional(),
+    }),
+    async (input) => {
+      return Storage.read<Snapshot.FileDiff[]>(["session_diff", input.sessionID]).catch(() => [])
+    },
+  )
+
+  async function computeDiff(input: { messages: MessageV2.WithParts[] }) {
+    let from: string | undefined
+    let to: string | undefined
+
+    // scan assistant messages to find earliest from and latest to
+    // snapshot
+    for (const item of input.messages) {
+      if (!from) {
+        for (const part of item.parts) {
+          if (part.type === "step-start" && part.snapshot) {
+            from = part.snapshot
+            break
+          }
+        }
+      }
+
+      for (const part of item.parts) {
+        if (part.type === "step-finish" && part.snapshot) {
+          to = part.snapshot
+          break
+        }
+      }
+    }
+
+    if (from && to) return Snapshot.diffFull(from, to)
+    return []
+  }
+}

package/src/session/system.ts

@@ -0,0 +1,122 @@
+import { Ripgrep } from "../file/ripgrep"
+import { Global } from "../global"
+import { Filesystem } from "../util/filesystem"
+import { Config } from "../config/config"
+import { Skill } from "../skill"
+
+import { Instance } from "../project/instance"
+import path from "path"
+import os from "os"
+
+import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
+import PROMPT_ANTHROPIC_WITHOUT_TODO from "./prompt/qwen.txt"
+import PROMPT_POLARIS from "./prompt/polaris.txt"
+import PROMPT_BEAST from "./prompt/beast.txt"
+import PROMPT_GEMINI from "./prompt/gemini.txt"
+import PROMPT_ANTHROPIC_SPOOF from "./prompt/anthropic_spoof.txt"
+
+import PROMPT_CODEX from "./prompt/codex.txt"
+import type { Provider } from "@/provider/provider"
+
+export namespace SystemPrompt {
+  export function header(providerID: string) {
+    if (providerID.includes("anthropic")) return [PROMPT_ANTHROPIC_SPOOF.trim()]
+    return []
+  }
+
+  export function provider(model: Provider.Model) {
+    if (model.api.id.includes("gpt-5")) return [PROMPT_CODEX]
+    if (model.api.id.includes("gpt-") || model.api.id.includes("o1") || model.api.id.includes("o3"))
+      return [PROMPT_BEAST]
+    if (model.api.id.includes("gemini-")) return [PROMPT_GEMINI]
+    if (model.api.id.includes("claude")) return [PROMPT_ANTHROPIC]
+    if (model.api.id.includes("polaris-alpha")) return [PROMPT_POLARIS]
+    return [PROMPT_ANTHROPIC_WITHOUT_TODO]
+  }
+
+  export async function environment() {
+    const project = Instance.project
+    return [
+      [
+        `Here is some useful information about the environment you are running in:`,
+        `<env>`,
+        `  Working directory: ${Instance.directory}`,
+        `  Is directory a git repo: ${project.vcs === "git" ? "yes" : "no"}`,
+        `  Platform: ${process.platform}`,
+        `  Today's date: ${new Date().toDateString()}`,
+        `</env>`,
+        `<files>`,
+        `  ${project.vcs === "git"
+          ? await Ripgrep.tree({
+            cwd: Instance.directory,
+            limit: 200,
+          })
+          : ""
+        }`,
+        `</files>`,
+      ].join("\n"),
+    ]
+  }
+
+  const LOCAL_RULE_FILES = [
+    "AGENTS.md",
+    "RIRD.md",
+    "RIRD.md",
+    "CONTEXT.md", // deprecated
+  ]
+  const GLOBAL_RULE_FILES = [
+    path.join(Global.Path.config, "AGENTS.md"),
+    path.join(os.homedir(), ".rird", "RIRD.md"),
+    path.join(os.homedir(), ".RIRD", "RIRD.md"),
+    path.join(os.homedir(), ".RIRD", "AGENTS.md"),
+  ]
+
+  export async function custom() {
+    const config = await Config.get()
+    const paths = new Set<string>()
+
+    for (const localRuleFile of LOCAL_RULE_FILES) {
+      const matches = await Filesystem.findUp(localRuleFile, Instance.directory, Instance.worktree)
+      if (matches.length > 0) {
+        matches.forEach((path) => paths.add(path))
+        break
+      }
+    }
+
+    for (const globalRuleFile of GLOBAL_RULE_FILES) {
+      if (await Bun.file(globalRuleFile).exists()) {
+        paths.add(globalRuleFile)
+        break
+      }
+    }
+
+    if (config.instructions) {
+      for (let instruction of config.instructions) {
+        if (instruction.startsWith("~/")) {
+          instruction = path.join(os.homedir(), instruction.slice(2))
+        }
+        let matches: string[] = []
+        if (path.isAbsolute(instruction)) {
+          matches = await Array.fromAsync(
+            new Bun.Glob(path.basename(instruction)).scan({
+              cwd: path.dirname(instruction),
+              absolute: true,
+              onlyFiles: true,
+            }),
+          ).catch(() => [])
+        } else {
+          matches = await Filesystem.globUp(instruction, Instance.directory, Instance.worktree).catch(() => [])
+        }
+        matches.forEach((path) => paths.add(path))
+      }
+    }
+
+    const found = Array.from(paths).map((p) =>
+      Bun.file(p)
+        .text()
+        .catch(() => "")
+        .then((x) => "Instructions from: " + p + "\n" + x),
+    )
+    return Promise.all(found).then((result) => result.filter(Boolean))
+  }
+}

package/src/session/todo.ts

@@ -0,0 +1,37 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import z from "zod"
+import { Storage } from "../storage/storage"
+
+export namespace Todo {
+  export const Info = z
+    .object({
+      content: z.string().describe("Brief description of the task"),
+      status: z.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
+      priority: z.string().describe("Priority level of the task: high, medium, low"),
+      id: z.string().describe("Unique identifier for the todo item"),
+    })
+    .meta({ ref: "Todo" })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: BusEvent.define(
+      "todo.updated",
+      z.object({
+        sessionID: z.string(),
+        todos: z.array(Info),
+      }),
+    ),
+  }
+
+  export async function update(input: { sessionID: string; todos: Info[] }) {
+    await Storage.write(["todo", input.sessionID], input.todos)
+    Bus.publish(Event.Updated, input)
+  }
+
+  export async function get(sessionID: string) {
+    return Storage.read<Info[]>(["todo", sessionID])
+      .then((x) => x || [])
+      .catch(() => [])
+  }
+}

package/src/share/share-next.ts

@@ -0,0 +1,222 @@
+import { Bus } from "@/bus"
+import { Config } from "@/config/config"
+import { ulid } from "ulid"
+import { Provider } from "@/provider/provider"
+import { Session } from "@/session"
+import { MessageV2 } from "@/session/message-v2"
+import { Storage } from "@/storage/storage"
+import { Log } from "@/util/log"
+import type * as SDK from "@opencode-ai/sdk/v2"
+
+export namespace ShareNext {
+  const log = Log.create({ service: "share-next" })
+
+  async function url() {
+    return process.env["RIRD_API"] ?? Config.get().then((x) => x.enterprise?.url ?? "https://api.rird.ai")
+  }
+
+  export async function init() {
+    return // Share disabled - no backend
+
+    Bus.subscribe(Session.Event.Updated, async (evt) => {
+      await sync(evt.properties.info.id, [
+        {
+          type: "session",
+          data: evt.properties.info,
+        },
+      ])
+    })
+    Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
+      await sync(evt.properties.info.sessionID, [
+        {
+          type: "message",
+          data: evt.properties.info,
+        },
+      ])
+      if (evt.properties.info.role === "user") {
+        await sync(evt.properties.info.sessionID, [
+          {
+            type: "model",
+            data: [
+              await Provider.getModel(evt.properties.info.model.providerID, evt.properties.info.model.modelID).then(
+                (m) => m,
+              ),
+            ],
+          },
+        ])
+      }
+    })
+    Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+      await sync(evt.properties.part.sessionID, [
+        {
+          type: "part",
+          data: evt.properties.part,
+        },
+      ])
+    })
+    Bus.subscribe(Session.Event.Diff, async (evt) => {
+      await sync(evt.properties.sessionID, [
+        {
+          type: "session_diff",
+          data: evt.properties.diff,
+        },
+      ])
+    })
+  }
+
+  export type CreateResult = { id: string; url: string; secret: string } | { error: string }
+
+  export async function create(sessionID: string): Promise<CreateResult> {
+    log.info("share disabled", { sessionID })
+    return { error: "Share feature coming soon" }
+
+    log.info("creating share", { sessionID })
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    }
+    if (process.env.RIRD_API_KEY) {
+      headers["Authorization"] = `Bearer ${process.env.RIRD_API_KEY}`
+    }
+
+    const result = await fetch(`${await url()}/api/share`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ sessionID: sessionID }),
+    })
+      .then((x) => x.json())
+      .then((x) => x as { id: string; url: string; secret: string })
+    await Storage.write(["session_share", sessionID], result)
+    fullSync(sessionID)
+    return result
+  }
+
+  async function get(sessionID: string) {
+    try {
+      return await Storage.read<{
+        id: string
+        secret: string
+        url: string
+      }>(["session_share", sessionID])
+    } catch {
+      // Session not shared - return undefined
+      return undefined
+    }
+  }
+
+  type Data =
+    | {
+        type: "session"
+        data: SDK.Session
+      }
+    | {
+        type: "message"
+        data: SDK.Message
+      }
+    | {
+        type: "part"
+        data: SDK.Part
+      }
+    | {
+        type: "session_diff"
+        data: SDK.FileDiff[]
+      }
+    | {
+        type: "model"
+        data: SDK.Model[]
+      }
+
+  const queue = new Map<string, { timeout: NodeJS.Timeout; data: Map<string, Data> }>()
+  async function sync(sessionID: string, data: Data[]) {
+    const existing = queue.get(sessionID)
+    if (existing) {
+      for (const item of data) {
+        existing.data.set("id" in item ? (item.id as string) : ulid(), item)
+      }
+      return
+    }
+
+    const dataMap = new Map<string, Data>()
+    for (const item of data) {
+      dataMap.set("id" in item ? (item.id as string) : ulid(), item)
+    }
+
+    const timeout = setTimeout(async () => {
+      const queued = queue.get(sessionID)
+      if (!queued) return
+      queue.delete(sessionID)
+      const share = await get(sessionID)
+      if (!share) return
+
+      const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+      }
+      if (process.env.RIRD_API_KEY) {
+        headers["Authorization"] = `Bearer ${process.env.RIRD_API_KEY}`
+      }
+
+      await fetch(`${await url()}/api/share/${share.id}/sync`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          secret: share.secret,
+          data: Array.from(queued.data.values()),
+        }),
+      })
+    }, 1000)
+    queue.set(sessionID, { timeout, data: dataMap })
+  }
+
+  export async function remove(sessionID: string) {
+    log.info("removing share", { sessionID })
+    const share = await get(sessionID)
+    if (!share) return
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    }
+    if (process.env.RIRD_API_KEY) {
+      headers["Authorization"] = `Bearer ${process.env.RIRD_API_KEY}`
+    }
+
+    await fetch(`${await url()}/api/share/${share.id}`, {
+      method: "DELETE",
+      headers,
+      body: JSON.stringify({
+        secret: share.secret,
+      }),
+    })
+    await Storage.remove(["session_share", sessionID])
+  }
+
+  async function fullSync(sessionID: string) {
+    log.info("full sync", { sessionID })
+    const session = await Session.get(sessionID)
+    const diffs = await Session.diff(sessionID)
+    const messages = await Array.fromAsync(MessageV2.stream(sessionID))
+    const models = await Promise.all(
+      messages
+        .filter((m) => m.info.role === "user")
+        .map((m) => (m.info as SDK.UserMessage).model)
+        .map((m) => Provider.getModel(m.providerID, m.modelID).then((m) => m)),
+    )
+    await sync(sessionID, [
+      {
+        type: "session",
+        data: session,
+      },
+      ...messages.map((x) => ({
+        type: "message" as const,
+        data: x.info,
+      })),
+      ...messages.flatMap((x) => x.parts.map((y) => ({ type: "part" as const, data: y }))),
+      {
+        type: "session_diff",
+        data: diffs,
+      },
+      {
+        type: "model",
+        data: models,
+      },
+    ])
+  }
+}

package/src/share/share.ts

@@ -0,0 +1,87 @@
+import { Bus } from "../bus"
+import { Installation } from "../installation"
+import { Session } from "../session"
+import { MessageV2 } from "../session/message-v2"
+import { Log } from "../util/log"
+
+export namespace Share {
+  const log = Log.create({ service: "share" })
+
+  let queue: Promise<void> = Promise.resolve()
+  const pending = new Map<string, any>()
+
+  export async function sync(key: string, content: any) {
+    const [root, ...splits] = key.split("/")
+    if (root !== "session") return
+    const [sub, sessionID] = splits
+    if (sub === "share") return
+    const share = await Session.getShare(sessionID).catch(() => {})
+    if (!share) return
+    const { secret } = share
+    pending.set(key, content)
+    queue = queue
+      .then(async () => {
+        const content = pending.get(key)
+        if (content === undefined) return
+        pending.delete(key)
+
+        return fetch(`${URL}/share_sync`, {
+          method: "POST",
+          body: JSON.stringify({
+            sessionID: sessionID,
+            secret,
+            key: key,
+            content,
+          }),
+        })
+      })
+      .then((x) => {
+        if (x) {
+          log.info("synced", {
+            key: key,
+            status: x.status,
+          })
+        }
+      })
+  }
+
+  export function init() {
+    Bus.subscribe(Session.Event.Updated, async (evt) => {
+      await sync("session/info/" + evt.properties.info.id, evt.properties.info)
+    })
+    Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
+      await sync("session/message/" + evt.properties.info.sessionID + "/" + evt.properties.info.id, evt.properties.info)
+    })
+    Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+      await sync(
+        "session/part/" +
+          evt.properties.part.sessionID +
+          "/" +
+          evt.properties.part.messageID +
+          "/" +
+          evt.properties.part.id,
+        evt.properties.part,
+      )
+    })
+  }
+
+  export const URL =
+    process.env["RIRD_API"] ??
+    (Installation.isPreview() || Installation.isLocal() ? "https://api.dev.rird.ai" : "https://api.rird.ai")
+
+  export async function create(sessionID: string) {
+    return fetch(`${URL}/share_create`, {
+      method: "POST",
+      body: JSON.stringify({ sessionID: sessionID }),
+    })
+      .then((x) => x.json())
+      .then((x) => x as { url: string; secret: string })
+  }
+
+  export async function remove(sessionID: string, secret: string) {
+    return fetch(`${URL}/share_delete`, {
+      method: "POST",
+      body: JSON.stringify({ sessionID, secret }),
+    }).then((x) => x.json())
+  }
+}