bonecode 1.0.0 → 1.2.0

package/src/engine/session/system.ts

@@ -1,84 +1,84 @@
-import { Context, Effect, Layer } from "effect"
-
-import { InstanceState } from "@/effect/instance-state"
-
-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 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 interface Interface {
-  readonly environment: (model: Provider.Model) => Effect.Effect<string[]>
-  readonly skills: (agent: Agent.Info) => Effect.Effect<string | undefined>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SystemPrompt") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const skill = yield* Skill.Service
-
-    return Service.of({
-      environment: Effect.fn("SystemPrompt.environment")(function* (model: Provider.Model) {
-        const ctx = yield* InstanceState.context
-        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: ${ctx.directory}`,
-            `  Workspace root folder: ${ctx.worktree}`,
-            `  Is directory a git repo: ${ctx.project.vcs === "git" ? "yes" : "no"}`,
-            `  Platform: ${process.platform}`,
-            `  Today's date: ${new Date().toDateString()}`,
-            `</env>`,
-          ].join("\n"),
-        ]
-      }),
-
-      skills: Effect.fn("SystemPrompt.skills")(function* (agent: Agent.Info) {
-        if (Permission.disabled(["skill"], agent.permission).has("skill")) return
-
-        const list = yield* 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")
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Skill.defaultLayer))
-
-export * as SystemPrompt from "./system"
+import { Context, Effect, Layer } from "effect"
+
+import { InstanceState } from "@/effect/instance-state"
+
+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 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 interface Interface {
+  readonly environment: (model: Provider.Model) => Effect.Effect<string[]>
+  readonly skills: (agent: Agent.Info) => Effect.Effect<string | undefined>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SystemPrompt") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const skill = yield* Skill.Service
+
+    return Service.of({
+      environment: Effect.fn("SystemPrompt.environment")(function* (model: Provider.Model) {
+        const ctx = yield* InstanceState.context
+        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: ${ctx.directory}`,
+            `  Workspace root folder: ${ctx.worktree}`,
+            `  Is directory a git repo: ${ctx.project.vcs === "git" ? "yes" : "no"}`,
+            `  Platform: ${process.platform}`,
+            `  Today's date: ${new Date().toDateString()}`,
+            `</env>`,
+          ].join("\n"),
+        ]
+      }),
+
+      skills: Effect.fn("SystemPrompt.skills")(function* (agent: Agent.Info) {
+        if (Permission.disabled(["skill"], agent.permission).has("skill")) return
+
+        const list = yield* 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")
+      }),
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Skill.defaultLayer))
+
+export * as SystemPrompt from "./system"

package/src/engine/session/todo.ts

@@ -1,81 +1,81 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { SessionID } from "./schema"
-import { Effect, Layer, Context, Schema } from "effect"
-import { Database } from "@/storage/db"
-import { eq } from "drizzle-orm"
-import { asc } from "drizzle-orm"
-import { TodoTable } from "./session.sql"
-
-export const Info = Schema.Struct({
-  content: Schema.String.annotate({ description: "Brief description of the task" }),
-  status: Schema.String.annotate({
-    description: "Current status of the task: pending, in_progress, completed, cancelled",
-  }),
-  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
-}).annotate({ identifier: "Todo" })
-export type Info = Schema.Schema.Type<typeof Info>
-
-export const Event = {
-  Updated: BusEvent.define(
-    "todo.updated",
-    Schema.Struct({
-      sessionID: SessionID,
-      todos: Schema.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 Context.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))
-
-export * as Todo from "./todo"
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { SessionID } from "./schema"
+import { Effect, Layer, Context, Schema } from "effect"
+import { Database } from "@/storage/db"
+import { eq } from "drizzle-orm"
+import { asc } from "drizzle-orm"
+import { TodoTable } from "./session.sql"
+
+export const Info = Schema.Struct({
+  content: Schema.String.annotate({ description: "Brief description of the task" }),
+  status: Schema.String.annotate({
+    description: "Current status of the task: pending, in_progress, completed, cancelled",
+  }),
+  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
+}).annotate({ identifier: "Todo" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+export const Event = {
+  Updated: BusEvent.define(
+    "todo.updated",
+    Schema.Struct({
+      sessionID: SessionID,
+      todos: Schema.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 Context.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))
+
+export * as Todo from "./todo"

package/src/engine/share/session.ts

@@ -1,61 +1,61 @@
-import { Session } from "@/session/session"
-import { SessionID } from "@/session/schema"
-import { SyncEvent } from "@/sync"
-import { Effect, Layer, Scope, Context } from "effect"
-import { Config } from "@/config/config"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import * as ShareNext from "./share-next"
-
-export interface Interface {
-  readonly create: (input?: Session.CreateInput) => Effect.Effect<Session.Info>
-  readonly share: (sessionID: SessionID) => Effect.Effect<{ url: string }, unknown>
-  readonly unshare: (sessionID: SessionID) => Effect.Effect<void, unknown>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionShare") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const cfg = yield* Config.Service
-    const session = yield* Session.Service
-    const shareNext = yield* ShareNext.Service
-    const scope = yield* Scope.Scope
-    const sync = yield* SyncEvent.Service
-    const flags = yield* RuntimeFlags.Service
-
-    const share = Effect.fn("SessionShare.share")(function* (sessionID: SessionID) {
-      const conf = yield* cfg.get()
-      if (conf.share === "disabled") throw new Error("Sharing is disabled in configuration")
-      const result = yield* shareNext.create(sessionID)
-      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: result.url } } })
-      return result
-    })
-
-    const unshare = Effect.fn("SessionShare.unshare")(function* (sessionID: SessionID) {
-      yield* shareNext.remove(sessionID)
-      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: null } } })
-    })
-
-    const create = Effect.fn("SessionShare.create")(function* (input?: Session.CreateInput) {
-      const result = yield* session.create(input)
-      if (result.parentID) return result
-      const conf = yield* cfg.get()
-      if (!(flags.autoShare || conf.share === "auto")) return result
-      yield* share(result.id).pipe(Effect.ignore, Effect.forkIn(scope))
-      return result
-    })
-
-    return Service.of({ create, share, unshare })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(ShareNext.defaultLayer),
-  Layer.provide(Session.defaultLayer),
-  Layer.provide(Config.defaultLayer),
-  Layer.provide(SyncEvent.defaultLayer),
-  Layer.provide(RuntimeFlags.defaultLayer),
-)
-
-export * as SessionShare from "./session"
+import { Session } from "@/session/session"
+import { SessionID } from "@/session/schema"
+import { SyncEvent } from "@/sync"
+import { Effect, Layer, Scope, Context } from "effect"
+import { Config } from "@/config/config"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import * as ShareNext from "./share-next"
+
+export interface Interface {
+  readonly create: (input?: Session.CreateInput) => Effect.Effect<Session.Info>
+  readonly share: (sessionID: SessionID) => Effect.Effect<{ url: string }, unknown>
+  readonly unshare: (sessionID: SessionID) => Effect.Effect<void, unknown>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SessionShare") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const cfg = yield* Config.Service
+    const session = yield* Session.Service
+    const shareNext = yield* ShareNext.Service
+    const scope = yield* Scope.Scope
+    const sync = yield* SyncEvent.Service
+    const flags = yield* RuntimeFlags.Service
+
+    const share = Effect.fn("SessionShare.share")(function* (sessionID: SessionID) {
+      const conf = yield* cfg.get()
+      if (conf.share === "disabled") throw new Error("Sharing is disabled in configuration")
+      const result = yield* shareNext.create(sessionID)
+      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: result.url } } })
+      return result
+    })
+
+    const unshare = Effect.fn("SessionShare.unshare")(function* (sessionID: SessionID) {
+      yield* shareNext.remove(sessionID)
+      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: null } } })
+    })
+
+    const create = Effect.fn("SessionShare.create")(function* (input?: Session.CreateInput) {
+      const result = yield* session.create(input)
+      if (result.parentID) return result
+      const conf = yield* cfg.get()
+      if (!(flags.autoShare || conf.share === "auto")) return result
+      yield* share(result.id).pipe(Effect.ignore, Effect.forkIn(scope))
+      return result
+    })
+
+    return Service.of({ create, share, unshare })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(ShareNext.defaultLayer),
+  Layer.provide(Session.defaultLayer),
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(SyncEvent.defaultLayer),
+  Layer.provide(RuntimeFlags.defaultLayer),
+)
+
+export * as SessionShare from "./session"