alchemylab-opencode 1.0.7 → 1.0.8

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

@@ -1,177 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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))
-  }
-}