bonecode 1.0.0 → 1.1.0

package/src/engine/data-migration.ts

@@ -1,161 +1,161 @@
-import { Context, Effect, Layer } from "effect"
-import { Database } from "./storage/db"
-import { DataMigrationTable } from "./data-migration.sql"
-import * as Log from "@opencode-ai/core/util/log"
-import { and, asc, eq, gt, inArray, sql } from "drizzle-orm"
-import { MessageTable, SessionTable } from "./session/session.sql"
-import type { SessionID } from "./session/schema"
-
-export type Migration<R = never> = {
-  name: string
-  run: Effect.Effect<void, unknown, R>
-}
-
-const log = Log.create({ service: "data-migration" })
-
-export interface Interface {}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/DataMigration") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const migrations: Migration[] = [
-      {
-        name: "session_usage_from_messages",
-        run: Effect.gen(function* () {
-          type Usage = {
-            cost: number
-            tokens: { input: number; output: number; reasoning: number; cache: { read: number; write: number } }
-          }
-
-          for (let cursor: SessionID | undefined, page = 1; ; page++) {
-            const next = yield* Effect.gen(function* () {
-              const sessions = yield* Effect.sync(() =>
-                Database.use((db) =>
-                  db
-                    .select({ id: SessionTable.id })
-                    .from(SessionTable)
-                    .where(cursor ? gt(SessionTable.id, cursor) : undefined)
-                    .orderBy(asc(SessionTable.id))
-                    .limit(100)
-                    .all(),
-                ),
-              )
-              if (sessions.length === 0) return
-
-              yield* Effect.sync(() =>
-                Database.transaction((db) => {
-                  const usageBySession = new Map<SessionID, Usage>(
-                    sessions.map((session) => [
-                      session.id,
-                      { cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } },
-                    ]),
-                  )
-
-                  for (const row of db
-                    .select({
-                      session_id: MessageTable.session_id,
-                      cost: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.cost'), 0)), 0)`,
-                      tokens_input: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.input'), 0)), 0)`,
-                      tokens_output: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.output'), 0)), 0)`,
-                      tokens_reasoning: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.reasoning'), 0)), 0)`,
-                      tokens_cache_read: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.cache.read'), 0)), 0)`,
-                      tokens_cache_write: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.cache.write'), 0)), 0)`,
-                    })
-                    .from(MessageTable)
-                    .where(
-                      and(
-                        inArray(
-                          MessageTable.session_id,
-                          sessions.map((session) => session.id),
-                        ),
-                        sql`json_extract(${MessageTable.data}, '$.role') = 'assistant'`,
-                      ),
-                    )
-                    .groupBy(MessageTable.session_id)
-                    .all()) {
-                    const current = usageBySession.get(row.session_id)
-                    if (!current) continue
-                    current.cost = row.cost
-                    current.tokens.input = row.tokens_input
-                    current.tokens.output = row.tokens_output
-                    current.tokens.reasoning = row.tokens_reasoning
-                    current.tokens.cache.read = row.tokens_cache_read
-                    current.tokens.cache.write = row.tokens_cache_write
-                  }
-
-                  for (const [sessionID, value] of usageBySession) {
-                    db.update(SessionTable)
-                      .set({
-                        cost: value.cost,
-                        tokens_input: value.tokens.input,
-                        tokens_output: value.tokens.output,
-                        tokens_reasoning: value.tokens.reasoning,
-                        tokens_cache_read: value.tokens.cache.read,
-                        tokens_cache_write: value.tokens.cache.write,
-                        time_updated: sql`${SessionTable.time_updated}`,
-                      })
-                      .where(eq(SessionTable.id, sessionID))
-                      .run()
-                  }
-                }),
-              )
-
-              return sessions.at(-1)?.id
-            }).pipe(
-              Effect.withSpan("DataMigration.sessionUsage.page", {
-                attributes: {
-                  "data_migration.name": "session_usage_from_messages",
-                  "data_migration.page": page,
-                  "data_migration.cursor": cursor ?? "",
-                },
-              }),
-            )
-            if (!next) return
-            cursor = next
-            yield* Effect.sleep("10 millis")
-          }
-        }),
-      },
-    ]
-
-    yield* Effect.gen(function* () {
-      if (migrations.length === 0) return
-
-      // Migrations run in a background fiber, so they must be resumable until
-      // their completion row is written.
-      for (const migration of migrations) {
-        const completed = Database.use((db) =>
-          db
-            .select({ name: DataMigrationTable.name })
-            .from(DataMigrationTable)
-            .where(eq(DataMigrationTable.name, migration.name))
-            .get(),
-        )
-        if (completed) continue
-
-        log.info("running data migration", { name: migration.name })
-        yield* migration.run.pipe(Effect.withSpan("DataMigration", { attributes: { name: migration.name } }))
-        Database.use((db) =>
-          db
-            .insert(DataMigrationTable)
-            .values({ name: migration.name, time_completed: Date.now() })
-            .onConflictDoNothing()
-            .run(),
-        )
-      }
-    }).pipe(
-      Effect.tapCause((cause) =>
-        Effect.logError("failed to run data migrations").pipe(Effect.annotateLogs("cause", cause)),
-      ),
-      Effect.ignore,
-      Effect.forkScoped,
-    )
-    return Service.of({})
-  }),
-)
-
-export const defaultLayer = layer
-
-export * as DataMigration from "./data-migration"
+import { Context, Effect, Layer } from "effect"
+import { Database } from "./storage/db"
+import { DataMigrationTable } from "./data-migration.sql"
+import * as Log from "@opencode-ai/core/util/log"
+import { and, asc, eq, gt, inArray, sql } from "drizzle-orm"
+import { MessageTable, SessionTable } from "./session/session.sql"
+import type { SessionID } from "./session/schema"
+
+export type Migration<R = never> = {
+  name: string
+  run: Effect.Effect<void, unknown, R>
+}
+
+const log = Log.create({ service: "data-migration" })
+
+export interface Interface {}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/DataMigration") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const migrations: Migration[] = [
+      {
+        name: "session_usage_from_messages",
+        run: Effect.gen(function* () {
+          type Usage = {
+            cost: number
+            tokens: { input: number; output: number; reasoning: number; cache: { read: number; write: number } }
+          }
+
+          for (let cursor: SessionID | undefined, page = 1; ; page++) {
+            const next = yield* Effect.gen(function* () {
+              const sessions = yield* Effect.sync(() =>
+                Database.use((db) =>
+                  db
+                    .select({ id: SessionTable.id })
+                    .from(SessionTable)
+                    .where(cursor ? gt(SessionTable.id, cursor) : undefined)
+                    .orderBy(asc(SessionTable.id))
+                    .limit(100)
+                    .all(),
+                ),
+              )
+              if (sessions.length === 0) return
+
+              yield* Effect.sync(() =>
+                Database.transaction((db) => {
+                  const usageBySession = new Map<SessionID, Usage>(
+                    sessions.map((session) => [
+                      session.id,
+                      { cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } },
+                    ]),
+                  )
+
+                  for (const row of db
+                    .select({
+                      session_id: MessageTable.session_id,
+                      cost: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.cost'), 0)), 0)`,
+                      tokens_input: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.input'), 0)), 0)`,
+                      tokens_output: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.output'), 0)), 0)`,
+                      tokens_reasoning: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.reasoning'), 0)), 0)`,
+                      tokens_cache_read: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.cache.read'), 0)), 0)`,
+                      tokens_cache_write: sql<number>`coalesce(sum(coalesce(json_extract(${MessageTable.data}, '$.tokens.cache.write'), 0)), 0)`,
+                    })
+                    .from(MessageTable)
+                    .where(
+                      and(
+                        inArray(
+                          MessageTable.session_id,
+                          sessions.map((session) => session.id),
+                        ),
+                        sql`json_extract(${MessageTable.data}, '$.role') = 'assistant'`,
+                      ),
+                    )
+                    .groupBy(MessageTable.session_id)
+                    .all()) {
+                    const current = usageBySession.get(row.session_id)
+                    if (!current) continue
+                    current.cost = row.cost
+                    current.tokens.input = row.tokens_input
+                    current.tokens.output = row.tokens_output
+                    current.tokens.reasoning = row.tokens_reasoning
+                    current.tokens.cache.read = row.tokens_cache_read
+                    current.tokens.cache.write = row.tokens_cache_write
+                  }
+
+                  for (const [sessionID, value] of usageBySession) {
+                    db.update(SessionTable)
+                      .set({
+                        cost: value.cost,
+                        tokens_input: value.tokens.input,
+                        tokens_output: value.tokens.output,
+                        tokens_reasoning: value.tokens.reasoning,
+                        tokens_cache_read: value.tokens.cache.read,
+                        tokens_cache_write: value.tokens.cache.write,
+                        time_updated: sql`${SessionTable.time_updated}`,
+                      })
+                      .where(eq(SessionTable.id, sessionID))
+                      .run()
+                  }
+                }),
+              )
+
+              return sessions.at(-1)?.id
+            }).pipe(
+              Effect.withSpan("DataMigration.sessionUsage.page", {
+                attributes: {
+                  "data_migration.name": "session_usage_from_messages",
+                  "data_migration.page": page,
+                  "data_migration.cursor": cursor ?? "",
+                },
+              }),
+            )
+            if (!next) return
+            cursor = next
+            yield* Effect.sleep("10 millis")
+          }
+        }),
+      },
+    ]
+
+    yield* Effect.gen(function* () {
+      if (migrations.length === 0) return
+
+      // Migrations run in a background fiber, so they must be resumable until
+      // their completion row is written.
+      for (const migration of migrations) {
+        const completed = Database.use((db) =>
+          db
+            .select({ name: DataMigrationTable.name })
+            .from(DataMigrationTable)
+            .where(eq(DataMigrationTable.name, migration.name))
+            .get(),
+        )
+        if (completed) continue
+
+        log.info("running data migration", { name: migration.name })
+        yield* migration.run.pipe(Effect.withSpan("DataMigration", { attributes: { name: migration.name } }))
+        Database.use((db) =>
+          db
+            .insert(DataMigrationTable)
+            .values({ name: migration.name, time_completed: Date.now() })
+            .onConflictDoNothing()
+            .run(),
+        )
+      }
+    }).pipe(
+      Effect.tapCause((cause) =>
+        Effect.logError("failed to run data migrations").pipe(Effect.annotateLogs("cause", cause)),
+      ),
+      Effect.ignore,
+      Effect.forkScoped,
+    )
+    return Service.of({})
+  }),
+)
+
+export const defaultLayer = layer
+
+export * as DataMigration from "./data-migration"

package/src/engine/effect/app-runtime.ts

@@ -1,143 +1,143 @@
-import { Layer, ManagedRuntime } from "effect"
-import { attach } from "./run-service"
-import * as Observability from "@opencode-ai/core/effect/observability"
-
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Bus } from "@/bus"
-import { Auth } from "@/auth"
-import { Account } from "@/account/account"
-import { Config } from "@/config/config"
-import { Git } from "@/git"
-import { Ripgrep } from "@/file/ripgrep"
-import { File } from "@/file"
-import { FileWatcher } from "@/file/watcher"
-import { Storage } from "@/storage/storage"
-import { Snapshot } from "@/snapshot"
-import { Plugin } from "@/plugin"
-import { ModelsDev } from "@opencode-ai/core/models"
-import { Provider } from "@/provider/provider"
-import { ProviderAuth } from "@/provider/auth"
-import { Agent } from "@/agent/agent"
-import { Skill } from "@/skill"
-import { Discovery } from "@/skill/discovery"
-import { Question } from "@/question"
-import { Permission } from "@/permission"
-import { Todo } from "@/session/todo"
-import { Session } from "@/session/session"
-import { SessionStatus } from "@/session/status"
-import { SessionRunState } from "@/session/run-state"
-import { SessionProcessor } from "@/session/processor"
-import { SessionCompaction } from "@/session/compaction"
-import { SessionRevert } from "@/session/revert"
-import { SessionSummary } from "@/session/summary"
-import { SessionPrompt } from "@/session/prompt"
-import { Instruction } from "@/session/instruction"
-import { LLM } from "@/session/llm"
-import { LSP } from "@/lsp/lsp"
-import { MCP } from "@/mcp"
-import { McpAuth } from "@/mcp/auth"
-import { Command } from "@/command"
-import { Truncate } from "@/tool/truncate"
-import { ToolRegistry } from "@/tool/registry"
-import { Format } from "@/format"
-import { InstanceLayer } from "@/project/instance-layer"
-import { Project } from "@/project/project"
-import { Vcs } from "@/project/vcs"
-import { Reference } from "@/reference/reference"
-import { Workspace } from "@/control-plane/workspace"
-import { Worktree } from "@/worktree"
-import { Pty } from "@/pty"
-import { PtyTicket } from "@/pty/ticket"
-import { Installation } from "@/installation"
-import { ShareNext } from "@/share/share-next"
-import { SessionShare } from "@/share/session"
-import { SyncEvent } from "@/sync"
-import { Npm } from "@opencode-ai/core/npm"
-import { memoMap } from "@opencode-ai/core/effect/memo-map"
-import { DataMigration } from "@/data-migration"
-import { BackgroundJob } from "@/background/job"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-
-export const AppLayer = Layer.mergeAll(
-  Npm.defaultLayer,
-  AppFileSystem.defaultLayer,
-  Bus.defaultLayer,
-  Auth.defaultLayer,
-  Account.defaultLayer,
-  Config.defaultLayer,
-  Git.defaultLayer,
-  Ripgrep.defaultLayer,
-  File.defaultLayer,
-  FileWatcher.defaultLayer,
-  Storage.defaultLayer,
-  Snapshot.defaultLayer,
-  Plugin.defaultLayer,
-  ModelsDev.defaultLayer,
-  Provider.defaultLayer,
-  ProviderAuth.defaultLayer,
-  Agent.defaultLayer,
-  Skill.defaultLayer,
-  Discovery.defaultLayer,
-  Question.defaultLayer,
-  Permission.defaultLayer,
-  Todo.defaultLayer,
-  Session.defaultLayer,
-  SessionStatus.defaultLayer,
-  BackgroundJob.defaultLayer,
-  RuntimeFlags.defaultLayer,
-  SessionRunState.defaultLayer,
-  SessionProcessor.defaultLayer,
-  SessionCompaction.defaultLayer,
-  SessionRevert.defaultLayer,
-  SessionSummary.defaultLayer,
-  SessionPrompt.defaultLayer,
-  Instruction.defaultLayer,
-  LLM.defaultLayer,
-  LSP.defaultLayer,
-  MCP.defaultLayer,
-  McpAuth.defaultLayer,
-  Command.defaultLayer,
-  Truncate.defaultLayer,
-  ToolRegistry.defaultLayer,
-  Format.defaultLayer,
-  Project.defaultLayer,
-  Vcs.defaultLayer,
-  Reference.defaultLayer,
-  Workspace.defaultLayer,
-  Worktree.appLayer,
-  Pty.defaultLayer,
-  PtyTicket.defaultLayer,
-  Installation.defaultLayer,
-  ShareNext.defaultLayer,
-  SessionShare.defaultLayer,
-  SyncEvent.defaultLayer,
-  EventV2Bridge.defaultLayer,
-  DataMigration.defaultLayer,
-).pipe(Layer.provideMerge(InstanceLayer.layer), Layer.provideMerge(Observability.layer))
-
-const rt = ManagedRuntime.make(AppLayer, { memoMap })
-type Runtime = Pick<typeof rt, "runSync" | "runPromise" | "runPromiseExit" | "runFork" | "runCallback" | "dispose">
-
-/** Services provided by AppRuntime — i.e. what an Effect run via AppRuntime.runPromise can yield. */
-export type AppServices = ManagedRuntime.ManagedRuntime.Services<typeof rt>
-const wrap = (effect: Parameters<typeof rt.runSync>[0]) => attach(effect as never) as never
-
-export const AppRuntime: Runtime = {
-  runSync(effect) {
-    return rt.runSync(wrap(effect))
-  },
-  runPromise(effect, options) {
-    return rt.runPromise(wrap(effect), options)
-  },
-  runPromiseExit(effect, options) {
-    return rt.runPromiseExit(wrap(effect), options)
-  },
-  runFork(effect) {
-    return rt.runFork(wrap(effect))
-  },
-  runCallback(effect) {
-    return rt.runCallback(wrap(effect))
-  },
-  dispose: () => rt.dispose(),
-}
+import { Layer, ManagedRuntime } from "effect"
+import { attach } from "./run-service"
+import * as Observability from "@opencode-ai/core/effect/observability"
+
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { Bus } from "@/bus"
+import { Auth } from "@/auth"
+import { Account } from "@/account/account"
+import { Config } from "@/config/config"
+import { Git } from "@/git"
+import { Ripgrep } from "@/file/ripgrep"
+import { File } from "@/file"
+import { FileWatcher } from "@/file/watcher"
+import { Storage } from "@/storage/storage"
+import { Snapshot } from "@/snapshot"
+import { Plugin } from "@/plugin"
+import { ModelsDev } from "@opencode-ai/core/models"
+import { Provider } from "@/provider/provider"
+import { ProviderAuth } from "@/provider/auth"
+import { Agent } from "@/agent/agent"
+import { Skill } from "@/skill"
+import { Discovery } from "@/skill/discovery"
+import { Question } from "@/question"
+import { Permission } from "@/permission"
+import { Todo } from "@/session/todo"
+import { Session } from "@/session/session"
+import { SessionStatus } from "@/session/status"
+import { SessionRunState } from "@/session/run-state"
+import { SessionProcessor } from "@/session/processor"
+import { SessionCompaction } from "@/session/compaction"
+import { SessionRevert } from "@/session/revert"
+import { SessionSummary } from "@/session/summary"
+import { SessionPrompt } from "@/session/prompt"
+import { Instruction } from "@/session/instruction"
+import { LLM } from "@/session/llm"
+import { LSP } from "@/lsp/lsp"
+import { MCP } from "@/mcp"
+import { McpAuth } from "@/mcp/auth"
+import { Command } from "@/command"
+import { Truncate } from "@/tool/truncate"
+import { ToolRegistry } from "@/tool/registry"
+import { Format } from "@/format"
+import { InstanceLayer } from "@/project/instance-layer"
+import { Project } from "@/project/project"
+import { Vcs } from "@/project/vcs"
+import { Reference } from "@/reference/reference"
+import { Workspace } from "@/control-plane/workspace"
+import { Worktree } from "@/worktree"
+import { Pty } from "@/pty"
+import { PtyTicket } from "@/pty/ticket"
+import { Installation } from "@/installation"
+import { ShareNext } from "@/share/share-next"
+import { SessionShare } from "@/share/session"
+import { SyncEvent } from "@/sync"
+import { Npm } from "@opencode-ai/core/npm"
+import { memoMap } from "@opencode-ai/core/effect/memo-map"
+import { DataMigration } from "@/data-migration"
+import { BackgroundJob } from "@/background/job"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+
+export const AppLayer = Layer.mergeAll(
+  Npm.defaultLayer,
+  AppFileSystem.defaultLayer,
+  Bus.defaultLayer,
+  Auth.defaultLayer,
+  Account.defaultLayer,
+  Config.defaultLayer,
+  Git.defaultLayer,
+  Ripgrep.defaultLayer,
+  File.defaultLayer,
+  FileWatcher.defaultLayer,
+  Storage.defaultLayer,
+  Snapshot.defaultLayer,
+  Plugin.defaultLayer,
+  ModelsDev.defaultLayer,
+  Provider.defaultLayer,
+  ProviderAuth.defaultLayer,
+  Agent.defaultLayer,
+  Skill.defaultLayer,
+  Discovery.defaultLayer,
+  Question.defaultLayer,
+  Permission.defaultLayer,
+  Todo.defaultLayer,
+  Session.defaultLayer,
+  SessionStatus.defaultLayer,
+  BackgroundJob.defaultLayer,
+  RuntimeFlags.defaultLayer,
+  SessionRunState.defaultLayer,
+  SessionProcessor.defaultLayer,
+  SessionCompaction.defaultLayer,
+  SessionRevert.defaultLayer,
+  SessionSummary.defaultLayer,
+  SessionPrompt.defaultLayer,
+  Instruction.defaultLayer,
+  LLM.defaultLayer,
+  LSP.defaultLayer,
+  MCP.defaultLayer,
+  McpAuth.defaultLayer,
+  Command.defaultLayer,
+  Truncate.defaultLayer,
+  ToolRegistry.defaultLayer,
+  Format.defaultLayer,
+  Project.defaultLayer,
+  Vcs.defaultLayer,
+  Reference.defaultLayer,
+  Workspace.defaultLayer,
+  Worktree.appLayer,
+  Pty.defaultLayer,
+  PtyTicket.defaultLayer,
+  Installation.defaultLayer,
+  ShareNext.defaultLayer,
+  SessionShare.defaultLayer,
+  SyncEvent.defaultLayer,
+  EventV2Bridge.defaultLayer,
+  DataMigration.defaultLayer,
+).pipe(Layer.provideMerge(InstanceLayer.layer), Layer.provideMerge(Observability.layer))
+
+const rt = ManagedRuntime.make(AppLayer, { memoMap })
+type Runtime = Pick<typeof rt, "runSync" | "runPromise" | "runPromiseExit" | "runFork" | "runCallback" | "dispose">
+
+/** Services provided by AppRuntime — i.e. what an Effect run via AppRuntime.runPromise can yield. */
+export type AppServices = ManagedRuntime.ManagedRuntime.Services<typeof rt>
+const wrap = (effect: Parameters<typeof rt.runSync>[0]) => attach(effect as never) as never
+
+export const AppRuntime: Runtime = {
+  runSync(effect) {
+    return rt.runSync(wrap(effect))
+  },
+  runPromise(effect, options) {
+    return rt.runPromise(wrap(effect), options)
+  },
+  runPromiseExit(effect, options) {
+    return rt.runPromiseExit(wrap(effect), options)
+  },
+  runFork(effect) {
+    return rt.runFork(wrap(effect))
+  },
+  runCallback(effect) {
+    return rt.runCallback(wrap(effect))
+  },
+  dispose: () => rt.dispose(),
+}