bincode-cli 1.0.1

package/src/session/retry.ts

@@ -0,0 +1,86 @@
+import type { NamedError } from "@bincode-ai/util/error"
+import { MessageV2 } from "./message-v2"
+
+export namespace SessionRetry {
+  export const RETRY_INITIAL_DELAY = 2000
+  export const RETRY_BACKOFF_FACTOR = 2
+  export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
+
+  export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(resolve, ms)
+      signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timeout)
+          reject(new DOMException("Aborted", "AbortError"))
+        },
+        { once: true },
+      )
+    })
+  }
+
+  export function delay(attempt: number, error?: MessageV2.APIError) {
+    if (error) {
+      const headers = error.data.responseHeaders
+      if (headers) {
+        const retryAfterMs = headers["retry-after-ms"]
+        if (retryAfterMs) {
+          const parsedMs = Number.parseFloat(retryAfterMs)
+          if (!Number.isNaN(parsedMs)) {
+            return parsedMs
+          }
+        }
+
+        const retryAfter = headers["retry-after"]
+        if (retryAfter) {
+          const parsedSeconds = Number.parseFloat(retryAfter)
+          if (!Number.isNaN(parsedSeconds)) {
+            // convert seconds to milliseconds
+            return Math.ceil(parsedSeconds * 1000)
+          }
+          // Try parsing as HTTP date format
+          const parsed = Date.parse(retryAfter) - Date.now()
+          if (!Number.isNaN(parsed) && parsed > 0) {
+            return Math.ceil(parsed)
+          }
+        }
+
+        return RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1)
+      }
+    }
+
+    return Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY_NO_HEADERS)
+  }
+
+  export function retryable(error: ReturnType<NamedError["toObject"]>) {
+    if (MessageV2.APIError.isInstance(error)) {
+      if (!error.data.isRetryable) return undefined
+      return error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message
+    }
+
+    if (typeof error.data?.message === "string") {
+      try {
+        const json = JSON.parse(error.data.message)
+        if (json.type === "error" && json.error?.type === "too_many_requests") {
+          return "Too Many Requests"
+        }
+        if (json.code.includes("exhausted") || json.code.includes("unavailable")) {
+          return "Provider is overloaded"
+        }
+        if (json.type === "error" && json.error?.code?.includes("rate_limit")) {
+          return "Rate Limited"
+        }
+        if (
+          json.error?.message?.includes("no_kv_space") ||
+          (json.type === "error" && json.error?.type === "server_error") ||
+          !!json.error
+        ) {
+          return "Provider Server Error"
+        }
+      } catch {}
+    }
+
+    return undefined
+  }
+}

package/src/session/revert.ts

@@ -0,0 +1,108 @@
+import z from "zod"
+import { Identifier } from "../id/id"
+import { Snapshot } from "../snapshot"
+import { MessageV2 } from "./message-v2"
+import { Session } from "."
+import { Log } from "../util/log"
+import { splitWhen } from "remeda"
+import { Storage } from "../storage/storage"
+import { Bus } from "../bus"
+import { SessionPrompt } from "./prompt"
+
+export namespace SessionRevert {
+  const log = Log.create({ service: "session.revert" })
+
+  export const RevertInput = z.object({
+    sessionID: Identifier.schema("session"),
+    messageID: Identifier.schema("message"),
+    partID: Identifier.schema("part").optional(),
+  })
+  export type RevertInput = z.infer<typeof RevertInput>
+
+  export async function revert(input: RevertInput) {
+    SessionPrompt.assertNotBusy(input.sessionID)
+    const all = await Session.messages({ sessionID: input.sessionID })
+    let lastUser: MessageV2.User | undefined
+    const session = await Session.get(input.sessionID)
+
+    let revert: Session.Info["revert"]
+    const patches: Snapshot.Patch[] = []
+    for (const msg of all) {
+      if (msg.info.role === "user") lastUser = msg.info
+      const remaining = []
+      for (const part of msg.parts) {
+        if (revert) {
+          if (part.type === "patch") {
+            patches.push(part)
+          }
+          continue
+        }
+
+        if (!revert) {
+          if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
+            // if no useful parts left in message, same as reverting whole message
+            const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
+            revert = {
+              messageID: !partID && lastUser ? lastUser.id : msg.info.id,
+              partID,
+            }
+          }
+          remaining.push(part)
+        }
+      }
+    }
+
+    if (revert) {
+      const session = await Session.get(input.sessionID)
+      revert.snapshot = session.revert?.snapshot ?? (await Snapshot.track())
+      await Snapshot.revert(patches)
+      if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot)
+      return Session.update(input.sessionID, (draft) => {
+        draft.revert = revert
+      })
+    }
+    return session
+  }
+
+  export async function unrevert(input: { sessionID: string }) {
+    log.info("unreverting", input)
+    SessionPrompt.assertNotBusy(input.sessionID)
+    const session = await Session.get(input.sessionID)
+    if (!session.revert) return session
+    if (session.revert.snapshot) await Snapshot.restore(session.revert.snapshot)
+    const next = await Session.update(input.sessionID, (draft) => {
+      draft.revert = undefined
+    })
+    return next
+  }
+
+  export async function cleanup(session: Session.Info) {
+    if (!session.revert) return
+    const sessionID = session.id
+    let msgs = await Session.messages({ sessionID })
+    const messageID = session.revert.messageID
+    const [preserve, remove] = splitWhen(msgs, (x) => x.info.id === messageID)
+    msgs = preserve
+    for (const msg of remove) {
+      await Storage.remove(["message", sessionID, msg.info.id])
+      await Bus.publish(MessageV2.Event.Removed, { sessionID: sessionID, messageID: msg.info.id })
+    }
+    const last = preserve.at(-1)
+    if (session.revert.partID && last) {
+      const partID = session.revert.partID
+      const [preserveParts, removeParts] = splitWhen(last.parts, (x) => x.id === partID)
+      last.parts = preserveParts
+      for (const part of removeParts) {
+        await Storage.remove(["part", last.info.id, part.id])
+        await Bus.publish(MessageV2.Event.PartRemoved, {
+          sessionID: sessionID,
+          messageID: last.info.id,
+          partID: part.id,
+        })
+      }
+    }
+    await Session.update(sessionID, (draft) => {
+      draft.revert = undefined
+    })
+  }
+}

package/src/session/status.ts

@@ -0,0 +1,76 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { Instance } from "@/project/instance"
+import z from "zod"
+
+export namespace SessionStatus {
+  export const Info = z
+    .union([
+      z.object({
+        type: z.literal("idle"),
+      }),
+      z.object({
+        type: z.literal("retry"),
+        attempt: z.number(),
+        message: z.string(),
+        next: z.number(),
+      }),
+      z.object({
+        type: z.literal("busy"),
+      }),
+    ])
+    .meta({
+      ref: "SessionStatus",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Status: BusEvent.define(
+      "session.status",
+      z.object({
+        sessionID: z.string(),
+        status: Info,
+      }),
+    ),
+    // deprecated
+    Idle: BusEvent.define(
+      "session.idle",
+      z.object({
+        sessionID: z.string(),
+      }),
+    ),
+  }
+
+  const state = Instance.state(() => {
+    const data: Record<string, Info> = {}
+    return data
+  })
+
+  export function get(sessionID: string) {
+    return (
+      state()[sessionID] ?? {
+        type: "idle",
+      }
+    )
+  }
+
+  export function list() {
+    return state()
+  }
+
+  export function set(sessionID: string, status: Info) {
+    Bus.publish(Event.Status, {
+      sessionID,
+      status,
+    })
+    if (status.type === "idle") {
+      // deprecated
+      Bus.publish(Event.Idle, {
+        sessionID,
+      })
+      delete state()[sessionID]
+      return
+    }
+    state()[sessionID] = status
+  }
+}

package/src/session/summary.ts

@@ -0,0 +1,194 @@
+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 Provider.getSmallModel(assistantMsg.providerID)) ??
+      (await Provider.getModel(assistantMsg.providerID, assistantMsg.modelID))
+
+    const textPart = msgWithParts.parts.find((p) => p.type === "text" && !p.synthetic) as MessageV2.TextPart
+    if (textPart && !userMsg.summary?.title) {
+      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 stream = await LLM.stream({
+          agent: summaryAgent,
+          user: userMsg,
+          tools: {},
+          model: summaryAgent.model
+            ? await Provider.getModel(summaryAgent.model.providerID, summaryAgent.model.modelID)
+            : small,
+          small: true,
+          messages: [
+            ...MessageV2.toModelMessage(messages),
+            {
+              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,120 @@
+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",
+    "CLAUDE.md",
+    "CONTEXT.md", // deprecated
+  ]
+  const GLOBAL_RULE_FILES = [
+    path.join(Global.Path.config, "AGENTS.md"),
+    path.join(os.homedir(), ".claude", "CLAUDE.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(() => [])
+  }
+}