bonecode 1.0.0

package/src/engine/session/status.ts

@@ -0,0 +1,94 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { InstanceState } from "@/effect/instance-state"
+import { SessionID } from "./schema"
+import { NonNegativeInt } from "@opencode-ai/core/schema"
+import { Effect, Layer, Context, Schema } from "effect"
+
+export const Info = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("idle"),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("retry"),
+    attempt: NonNegativeInt,
+    message: Schema.String,
+    action: Schema.optional(
+      Schema.Struct({
+        reason: Schema.String,
+        provider: Schema.String,
+        title: Schema.String,
+        message: Schema.String,
+        label: Schema.String,
+        link: Schema.optional(Schema.String),
+      }),
+    ),
+    next: NonNegativeInt,
+  }),
+  Schema.Struct({
+    type: Schema.Literal("busy"),
+  }),
+]).annotate({ identifier: "SessionStatus" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+export const Event = {
+  Status: BusEvent.define(
+    "session.status",
+    Schema.Struct({
+      sessionID: SessionID,
+      status: Info,
+    }),
+  ),
+  // deprecated
+  Idle: BusEvent.define(
+    "session.idle",
+    Schema.Struct({
+      sessionID: SessionID,
+    }),
+  ),
+}
+
+export interface Interface {
+  readonly get: (sessionID: SessionID) => Effect.Effect<Info>
+  readonly list: () => Effect.Effect<Map<SessionID, Info>>
+  readonly set: (sessionID: SessionID, status: Info) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SessionStatus") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+
+    const state = yield* InstanceState.make(
+      Effect.fn("SessionStatus.state")(() => Effect.succeed(new Map<SessionID, Info>())),
+    )
+
+    const get = Effect.fn("SessionStatus.get")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      return data.get(sessionID) ?? { type: "idle" as const }
+    })
+
+    const list = Effect.fn("SessionStatus.list")(function* () {
+      return new Map(yield* InstanceState.get(state))
+    })
+
+    const set = Effect.fn("SessionStatus.set")(function* (sessionID: SessionID, status: Info) {
+      const data = yield* InstanceState.get(state)
+      yield* bus.publish(Event.Status, { sessionID, status })
+      if (status.type === "idle") {
+        yield* bus.publish(Event.Idle, { sessionID })
+        data.delete(sessionID)
+        return
+      }
+      data.set(sessionID, status)
+    })
+
+    return Service.of({ get, list, set })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
+
+export * as SessionStatus from "./status"

package/src/engine/session/summary.ts

@@ -0,0 +1,164 @@
+import { Effect, Layer, Context, Schema } from "effect"
+import { Bus } from "@/bus"
+import { Snapshot } from "@/snapshot"
+import { Storage } from "@/storage/storage"
+import * as Session from "./session"
+import { MessageV2 } from "./message-v2"
+import { SessionID, MessageID } from "./schema"
+
+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 Context.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 }).pipe(Effect.orDie)
+      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) => {
+        if (item.file === undefined) return 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.suspend(() =>
+  layer.pipe(
+    Layer.provide(Session.defaultLayer),
+    Layer.provide(Snapshot.defaultLayer),
+    Layer.provide(Storage.defaultLayer),
+    Layer.provide(Bus.layer),
+  ),
+)
+
+export const DiffInput = Schema.Struct({
+  sessionID: SessionID,
+  messageID: Schema.optional(MessageID),
+})
+export type DiffInput = Schema.Schema.Type<typeof DiffInput>
+
+export * as SessionSummary from "./summary"

package/src/engine/session/system.ts

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

package/src/engine/session/system_prompt.ts

@@ -0,0 +1,65 @@
+/**
+ * System prompt selection — ported from OpenCode's session/system.ts
+ * Selects the right provider-specific prompt, same logic as OpenCode.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+// Load prompt files from the copied OpenCode prompts directory
+function loadPrompt(name: string): string {
+  const promptDir = path.join(__dirname, "prompt");
+  const filePath = path.join(promptDir, name);
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+// Lazy-loaded prompts
+let _prompts: Record<string, string> | null = null;
+function prompts(): Record<string, string> {
+  if (_prompts) return _prompts;
+  _prompts = {
+    anthropic: loadPrompt("anthropic.txt"),
+    default: loadPrompt("default.txt"),
+    beast: loadPrompt("beast.txt"),
+    gemini: loadPrompt("gemini.txt"),
+    gpt: loadPrompt("gpt.txt"),
+    kimi: loadPrompt("kimi.txt"),
+    codex: loadPrompt("codex.txt"),
+    trinity: loadPrompt("trinity.txt"),
+  };
+  return _prompts;
+}
+
+/**
+ * Returns the provider-specific system prompt for a model.
+ * Exact same logic as OpenCode's SystemPrompt.provider().
+ */
+export function getSystemPrompt(model_id: string, provider_id: string, agent_name: string): string {
+  const p = prompts();
+  const id = model_id.toLowerCase();
+
+  let base: string;
+  if (id.includes("gpt-4") || id.includes("o1") || id.includes("o3")) {
+    base = p.beast;
+  } else if (id.includes("gpt") && id.includes("codex")) {
+    base = p.codex;
+  } else if (id.includes("gpt")) {
+    base = p.gpt;
+  } else if (id.includes("gemini-")) {
+    base = p.gemini;
+  } else if (id.includes("claude")) {
+    base = p.anthropic;
+  } else if (id.includes("trinity")) {
+    base = p.trinity;
+  } else if (id.includes("kimi")) {
+    base = p.kimi;
+  } else {
+    base = p.default;
+  }
+
+  return base || p.default || "You are a helpful coding assistant.";
+}

package/src/engine/session/todo.ts

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

package/src/engine/session/tool_registry.ts

@@ -0,0 +1,162 @@
+/**
+ * Tool registry — builds the tool set for a session using Zod schemas.
+ * All tools route execution through the BoneCode extension point (tool_executor.ts).
+ */
+
+import { tool } from "ai";
+import { z } from "zod";
+import { execute_tool_calls } from "../../../bone/output/session/src/extensions";
+import { pool } from "../../../bone/output/session/src/db";
+
+export async function buildToolRegistry(
+  session_id: string,
+  agent_id: string,
+  workspace_root: string
+): Promise<Record<string, any>> {
+  const tools: Record<string, any> = {};
+
+  // Helper: wrap a tool so execution goes through our BoneCode extension point
+  const makeTool = (name: string, description: string, schema: z.ZodObject<any>) => {
+    return tool({
+      description,
+      parameters: schema,
+      execute: async (args: any, opts: any) => {
+        const results = await execute_tool_calls(session_id, [{
+          id: (opts as any)?.toolCallId || name + "-" + Date.now(),
+          tool_name: name,
+          tool_input: args,
+        }]);
+        const result = results[0]?.result;
+        if (!result) return { output: "", title: name };
+        return { output: result.output || result.error || "", title: name };
+      },
+    });
+  };
+
+  // ── File tools ──────────────────────────────────────────────────────────────
+
+  tools["read"] = makeTool("read_file",
+    "Read the contents of a file. Supports optional line range with start_line and end_line.",
+    z.object({
+      path: z.string().describe("File path relative to workspace root"),
+      start_line: z.number().optional().describe("First line to read (1-indexed)"),
+      end_line: z.number().optional().describe("Last line to read inclusive"),
+    })
+  );
+
+  tools["write"] = makeTool("write_file",
+    "Write content to a file, creating it if it doesn't exist.",
+    z.object({
+      path: z.string().describe("File path relative to workspace root"),
+      content: z.string().describe("Content to write"),
+    })
+  );
+
+  tools["edit"] = makeTool("edit_file",
+    "Replace a specific string in a file with new content. The old_str must match exactly.",
+    z.object({
+      path: z.string().describe("File path relative to workspace root"),
+      old_str: z.string().describe("Exact string to find and replace"),
+      new_str: z.string().describe("Replacement string"),
+    })
+  );
+
+  tools["apply_patch"] = makeTool("apply_patch",
+    "Apply a unified diff patch to files. Use for complex multi-file edits.",
+    z.object({
+      patch: z.string().describe("Unified diff patch content"),
+    })
+  );
+
+  // ── Shell ───────────────────────────────────────────────────────────────────
+
+  tools["bash"] = makeTool("run_command",
+    "Execute a shell command in the workspace directory. Use for running tests, builds, git operations.",
+    z.object({
+      command: z.string().describe("Shell command to execute"),
+      cwd: z.string().optional().describe("Working directory (optional)"),
+      timeout_ms: z.number().optional().describe("Timeout in milliseconds (default 30000)"),
+    })
+  );
+
+  // ── Search ──────────────────────────────────────────────────────────────────
+
+  tools["glob"] = makeTool("glob",
+    "Find files matching a glob pattern in the workspace.",
+    z.object({
+      pattern: z.string().describe("Glob pattern (e.g. **/*.ts)"),
+    })
+  );
+
+  tools["grep"] = makeTool("search_files",
+    "Search for a regex pattern across files using ripgrep.",
+    z.object({
+      pattern: z.string().describe("Regex pattern to search for"),
+      glob: z.string().optional().describe("File glob to restrict search (e.g. **/*.ts)"),
+    })
+  );
+
+  tools["list_directory"] = makeTool("list_directory",
+    "List the contents of a directory.",
+    z.object({
+      path: z.string().optional().describe("Directory path (default: workspace root)"),
+    })
+  );
+
+  // ── Web ─────────────────────────────────────────────────────────────────────
+
+  tools["webfetch"] = tool({
+    description: "Fetch the content of a URL.",
+    parameters: z.object({
+      url: z.string().describe("URL to fetch"),
+      max_length: z.number().optional().describe("Maximum characters to return (default 10000)"),
+    }),
+    execute: async (args) => {
+      try {
+        const r = await fetch(args.url, { signal: AbortSignal.timeout(15_000) });
+        const text = await r.text();
+        return { output: text.slice(0, args.max_length || 10_000), title: "webfetch" };
+      } catch (e: any) {
+        return { output: `Error fetching ${args.url}: ${e.message}`, title: "webfetch" };
+      }
+    },
+  });
+
+  // ── Todo ────────────────────────────────────────────────────────────────────
+
+  tools["todo_write"] = tool({
+    description: "Manage a structured task list for the current session.",
+    parameters: z.object({
+      todos: z.array(z.object({
+        id: z.string(),
+        content: z.string(),
+        status: z.enum(["pending", "in_progress", "completed"]),
+        priority: z.enum(["high", "medium", "low"]),
+      })),
+    }),
+    execute: async (args) => {
+      await pool.query(
+        `UPDATE sessions SET permission_ruleset = jsonb_set(COALESCE(permission_ruleset, '{}'), '{todos}', $2::jsonb), updated_at = NOW() WHERE id = $1`,
+        [session_id, JSON.stringify(args.todos)]
+      );
+      const done = args.todos.filter(t => t.status === "completed").length;
+      return { output: `Updated ${args.todos.length} todos (${done} done)`, title: "todo_write" };
+    },
+  });
+
+  // ── Invalid (graceful handling of malformed tool calls) ─────────────────────
+
+  tools["invalid"] = tool({
+    description: "Called when the model uses an unknown tool name.",
+    parameters: z.object({
+      tool: z.string().optional(),
+      error: z.string().optional(),
+    }),
+    execute: async (args) => ({
+      output: `Unknown tool: ${args.tool || "unknown"}. Available: ${Object.keys(tools).filter(t => t !== "invalid").join(", ")}`,
+      title: "invalid",
+    }),
+  });
+
+  return tools;
+}