alchemylab-opencode 1.0.0

package/packages/opencode/src/session/summary.ts

@@ -0,0 +1,177 @@
+import z from "zod"
+import { Effect, Layer, ServiceMap } from "effect"
+import { makeRuntime } from "@/effect/run-service"
+import { Bus } from "@/bus"
+import { Snapshot } from "@/snapshot"
+import { Storage } from "@/storage/storage"
+import { Session } from "."
+import { MessageV2 } from "./message-v2"
+import { SessionID, MessageID } from "./schema"
+
+export namespace SessionSummary {
+  function unquoteGitPath(input: string) {
+    if (!input.startsWith('"')) return input
+    if (!input.endsWith('"')) return input
+    const body = input.slice(1, -1)
+    const bytes: number[] = []
+
+    for (let i = 0; i < body.length; i++) {
+      const char = body[i]!
+      if (char !== "\\") {
+        bytes.push(char.charCodeAt(0))
+        continue
+      }
+
+      const next = body[i + 1]
+      if (!next) {
+        bytes.push("\\".charCodeAt(0))
+        continue
+      }
+
+      if (next >= "0" && next <= "7") {
+        const chunk = body.slice(i + 1, i + 4)
+        const match = chunk.match(/^[0-7]{1,3}/)
+        if (!match) {
+          bytes.push(next.charCodeAt(0))
+          i++
+          continue
+        }
+        bytes.push(parseInt(match[0], 8))
+        i += match[0].length
+        continue
+      }
+
+      const escaped =
+        next === "n"
+          ? "\n"
+          : next === "r"
+            ? "\r"
+            : next === "t"
+              ? "\t"
+              : next === "b"
+                ? "\b"
+                : next === "f"
+                  ? "\f"
+                  : next === "v"
+                    ? "\v"
+                    : next === "\\" || next === '"'
+                      ? next
+                      : undefined
+
+      bytes.push((escaped ?? next).charCodeAt(0))
+      i++
+    }
+
+    return Buffer.from(bytes).toString()
+  }
+
+  export interface Interface {
+    readonly summarize: (input: { sessionID: SessionID; messageID: MessageID }) => Effect.Effect<void>
+    readonly diff: (input: { sessionID: SessionID; messageID?: MessageID }) => Effect.Effect<Snapshot.FileDiff[]>
+    readonly computeDiff: (input: { messages: MessageV2.WithParts[] }) => Effect.Effect<Snapshot.FileDiff[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SessionSummary") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const sessions = yield* Session.Service
+      const snapshot = yield* Snapshot.Service
+      const storage = yield* Storage.Service
+      const bus = yield* Bus.Service
+
+      const computeDiff = Effect.fn("SessionSummary.computeDiff")(function* (input: {
+        messages: MessageV2.WithParts[]
+      }) {
+        let from: string | undefined
+        let to: string | undefined
+        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
+          }
+        }
+        if (from && to) return yield* snapshot.diffFull(from, to)
+        return []
+      })
+
+      const summarize = Effect.fn("SessionSummary.summarize")(function* (input: {
+        sessionID: SessionID
+        messageID: MessageID
+      }) {
+        const all = yield* sessions.messages({ sessionID: input.sessionID })
+        if (!all.length) return
+
+        const diffs = yield* computeDiff({ messages: all })
+        yield* sessions.setSummary({
+          sessionID: input.sessionID,
+          summary: {
+            additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+            deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+            files: diffs.length,
+          },
+        })
+        yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
+        yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
+
+        const messages = all.filter(
+          (m) => m.info.id === input.messageID || (m.info.role === "assistant" && m.info.parentID === input.messageID),
+        )
+        const target = messages.find((m) => m.info.id === input.messageID)
+        if (!target || target.info.role !== "user") return
+        const msgDiffs = yield* computeDiff({ messages })
+        target.info.summary = { ...target.info.summary, diffs: msgDiffs }
+        yield* sessions.updateMessage(target.info)
+      })
+
+      const diff = Effect.fn("SessionSummary.diff")(function* (input: { sessionID: SessionID; messageID?: MessageID }) {
+        const diffs = yield* storage
+          .read<Snapshot.FileDiff[]>(["session_diff", input.sessionID])
+          .pipe(Effect.catch(() => Effect.succeed([] as Snapshot.FileDiff[])))
+        const next = diffs.map((item) => {
+          const file = unquoteGitPath(item.file)
+          if (file === item.file) return item
+          return { ...item, file }
+        })
+        const changed = next.some((item, i) => item.file !== diffs[i]?.file)
+        if (changed) yield* storage.write(["session_diff", input.sessionID], next).pipe(Effect.ignore)
+        return next
+      })
+
+      return Service.of({ summarize, diff, computeDiff })
+    }),
+  )
+
+  export const defaultLayer = Layer.unwrap(
+    Effect.sync(() =>
+      layer.pipe(
+        Layer.provide(Session.defaultLayer),
+        Layer.provide(Snapshot.defaultLayer),
+        Layer.provide(Storage.defaultLayer),
+        Layer.provide(Bus.layer),
+      ),
+    ),
+  )
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export const summarize = (input: { sessionID: SessionID; messageID: MessageID }) =>
+    void runPromise((svc) => svc.summarize(input)).catch(() => {})
+
+  export const DiffInput = z.object({
+    sessionID: SessionID.zod,
+    messageID: MessageID.zod.optional(),
+  })
+
+  export async function diff(input: z.infer<typeof DiffInput>) {
+    return runPromise((svc) => svc.diff(input))
+  }
+}

package/packages/opencode/src/session/system.ts

@@ -0,0 +1,76 @@
+import { Ripgrep } from "../file/ripgrep"
+
+import { Instance } from "../project/instance"
+
+import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
+import PROMPT_DEFAULT from "./prompt/default.txt"
+import PROMPT_BEAST from "./prompt/beast.txt"
+import PROMPT_GEMINI from "./prompt/gemini.txt"
+import PROMPT_GPT from "./prompt/gpt.txt"
+import PROMPT_KIMI from "./prompt/kimi.txt"
+
+import PROMPT_CODEX from "./prompt/codex.txt"
+import PROMPT_TRINITY from "./prompt/trinity.txt"
+import type { Provider } from "@/provider/provider"
+import type { Agent } from "@/agent/agent"
+import { Permission } from "@/permission"
+import { Skill } from "@/skill"
+
+export namespace SystemPrompt {
+  export function provider(model: Provider.Model) {
+    if (model.api.id.includes("gpt-4") || model.api.id.includes("o1") || model.api.id.includes("o3"))
+      return [PROMPT_BEAST]
+    if (model.api.id.includes("gpt")) {
+      if (model.api.id.includes("codex")) {
+        return [PROMPT_CODEX]
+      }
+      return [PROMPT_GPT]
+    }
+    if (model.api.id.includes("gemini-")) return [PROMPT_GEMINI]
+    if (model.api.id.includes("claude")) return [PROMPT_ANTHROPIC]
+    if (model.api.id.toLowerCase().includes("trinity")) return [PROMPT_TRINITY]
+    if (model.api.id.toLowerCase().includes("kimi")) return [PROMPT_KIMI]
+    return [PROMPT_DEFAULT]
+  }
+
+  export async function environment(model: Provider.Model) {
+    const project = Instance.project
+    return [
+      [
+        `You are powered by the model named ${model.api.id}. The exact model ID is ${model.providerID}/${model.api.id}`,
+        `Here is some useful information about the environment you are running in:`,
+        `<env>`,
+        `  Working directory: ${Instance.directory}`,
+        `  Workspace root folder: ${Instance.worktree}`,
+        `  Is directory a git repo: ${project.vcs === "git" ? "yes" : "no"}`,
+        `  Platform: ${process.platform}`,
+        `  Today's date: ${new Date().toDateString()}`,
+        `</env>`,
+        `<directories>`,
+        `  ${
+          project.vcs === "git" && false
+            ? await Ripgrep.tree({
+                cwd: Instance.directory,
+                limit: 50,
+              })
+            : ""
+        }`,
+        `</directories>`,
+      ].join("\n"),
+    ]
+  }
+
+  export async function skills(agent: Agent.Info) {
+    if (Permission.disabled(["skill"], agent.permission).has("skill")) return
+
+    const list = await Skill.available(agent)
+
+    return [
+      "Skills provide specialized instructions and workflows for specific tasks.",
+      "Use the skill tool to load a skill when a task matches its description.",
+      // the agents seem to ingest the information about skills a bit better if we present a more verbose
+      // version of them here and a less verbose version in tool description, rather than vice versa.
+      Skill.fmt(list, { verbose: true }),
+    ].join("\n")
+  }
+}

package/packages/opencode/src/session/todo.ts

@@ -0,0 +1,95 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { makeRuntime } from "@/effect/run-service"
+import { SessionID } from "./schema"
+import { Effect, Layer, ServiceMap } from "effect"
+import z from "zod"
+import { Database, eq, asc } from "../storage/db"
+import { TodoTable } from "./session.sql"
+
+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"),
+    })
+    .meta({ ref: "Todo" })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: BusEvent.define(
+      "todo.updated",
+      z.object({
+        sessionID: SessionID.zod,
+        todos: z.array(Info),
+      }),
+    ),
+  }
+
+  export interface Interface {
+    readonly update: (input: { sessionID: SessionID; todos: Info[] }) => Effect.Effect<void>
+    readonly get: (sessionID: SessionID) => Effect.Effect<Info[]>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SessionTodo") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+
+      const update = Effect.fn("Todo.update")(function* (input: { sessionID: SessionID; todos: Info[] }) {
+        yield* Effect.sync(() =>
+          Database.transaction((db) => {
+            db.delete(TodoTable).where(eq(TodoTable.session_id, input.sessionID)).run()
+            if (input.todos.length === 0) return
+            db.insert(TodoTable)
+              .values(
+                input.todos.map((todo, position) => ({
+                  session_id: input.sessionID,
+                  content: todo.content,
+                  status: todo.status,
+                  priority: todo.priority,
+                  position,
+                })),
+              )
+              .run()
+          }),
+        )
+        yield* bus.publish(Event.Updated, input)
+      })
+
+      const get = Effect.fn("Todo.get")(function* (sessionID: SessionID) {
+        const rows = yield* Effect.sync(() =>
+          Database.use((db) =>
+            db
+              .select()
+              .from(TodoTable)
+              .where(eq(TodoTable.session_id, sessionID))
+              .orderBy(asc(TodoTable.position))
+              .all(),
+          ),
+        )
+        return rows.map((row) => ({
+          content: row.content,
+          status: row.status,
+          priority: row.priority,
+        }))
+      })
+
+      return Service.of({ update, get })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function update(input: { sessionID: SessionID; todos: Info[] }) {
+    return runPromise((svc) => svc.update(input))
+  }
+
+  export async function get(sessionID: SessionID) {
+    return runPromise((svc) => svc.get(sessionID))
+  }
+}