bonecode 1.0.0

package/src/engine/session/compaction_logic.ts

@@ -0,0 +1,120 @@
+/**
+ * Context compaction — ported from OpenCode's session/compaction.ts
+ * Same SUMMARY_TEMPLATE and algorithm, no Effect.js.
+ */
+
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { generateText } from "ai";
+
+// Verbatim from OpenCode — this template is battle-tested
+const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
+<template>
+## Goal
+- [single-sentence task summary]
+
+## Constraints & Preferences
+- [user constraints, preferences, specs, or "(none)"]
+
+## Progress
+### Done
+- [completed work or "(none)"]
+
+### In Progress
+- [current work or "(none)"]
+
+### Blocked
+- [blockers or "(none)"]
+
+## Key Decisions
+- [decision and why, or "(none)"]
+
+## Next Steps
+- [ordered next actions or "(none)"]
+
+## Critical Context
+- [important technical facts, errors, open questions, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
+</template>
+
+Rules:
+- Keep every section, even when empty.
+- Use terse bullets, not prose paragraphs.
+- Preserve exact file paths, commands, error strings, and identifiers when known.
+- Do not mention the summary process or that context was compacted.`;
+
+export interface CompactionInput {
+  messages: any[];
+  model_id: string;
+  provider_id: string;
+  session_id: string;
+}
+
+export async function buildCompactionSummary(input: CompactionInput): Promise<string | null> {
+  const { messages, model_id, provider_id } = input;
+
+  // Build conversation text for summarization
+  // Strip tool outputs > 2000 chars (same as OpenCode's TOOL_OUTPUT_MAX_CHARS)
+  const TOOL_OUTPUT_MAX = 2_000;
+  const conversationLines: string[] = [];
+
+  for (const msg of messages) {
+    const parts = msg.parts || [];
+    if (msg.role === "user") {
+      const text = parts.filter((p: any) => p.part_type === "text").map((p: any) => p.data?.text || "").join("\n");
+      if (text.trim()) conversationLines.push(`User: ${text.trim()}`);
+    } else if (msg.role === "assistant") {
+      for (const p of parts) {
+        if (p.part_type === "text" && p.data?.text && !p.data?.is_compaction_summary) {
+          conversationLines.push(`Assistant: ${p.data.text.trim()}`);
+        } else if (p.part_type === "tool_invocation") {
+          conversationLines.push(`Tool call: ${p.data?.tool_name}(${JSON.stringify(p.data?.args || {}).slice(0, 200)})`);
+        } else if (p.part_type === "tool_result") {
+          const output = String(p.data?.result || "").slice(0, TOOL_OUTPUT_MAX);
+          conversationLines.push(`Tool result: ${output}`);
+        }
+      }
+    }
+  }
+
+  if (conversationLines.length === 0) return null;
+
+  const prompt = [
+    "Create a new anchored summary from the conversation history above.",
+    SUMMARY_TEMPLATE,
+    "",
+    "<conversation>",
+    conversationLines.join("\n"),
+    "</conversation>",
+  ].join("\n\n");
+
+  try {
+    const model = getCompactionModel(provider_id, model_id);
+    const { text } = await generateText({
+      model,
+      messages: [{ role: "user", content: prompt }],
+      maxTokens: 4096,
+      temperature: 0,
+    });
+    return text.replace(/<think>[\s\S]*?<\/think>\s*/g, "").trim();
+  } catch (e: any) {
+    return null;
+  }
+}
+
+function getCompactionModel(provider_id: string, model_id: string): any {
+  const apiKey = process.env[`${provider_id.toUpperCase()}_API_KEY`] || process.env.OPENAI_API_KEY || "not-needed";
+  const baseUrl = process.env[`${provider_id.toUpperCase()}_BASE_URL`] || process.env.OPENAI_BASE_URL;
+
+  // Use a smaller/faster model for compaction if available
+  const compactionModel = process.env.COMPACTION_MODEL || model_id;
+
+  switch (provider_id.toLowerCase()) {
+    case "anthropic":
+      return createAnthropic({ apiKey, baseURL: baseUrl })(compactionModel);
+    default:
+      return createOpenAI({ apiKey, baseURL: baseUrl })(compactionModel);
+  }
+}

package/src/engine/session/instruction.ts

@@ -0,0 +1,238 @@
+import path from "path"
+import { Effect, Layer, Context } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Config } from "@/config/config"
+import { InstanceState } from "@/effect/instance-state"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { AppFileSystem } from "@opencode-ai/core/filesystem"
+import { withTransientReadRetry } from "@/util/effect-http-client"
+import { Global } from "@opencode-ai/core/global"
+import type { MessageV2 } from "./message-v2"
+import type { MessageID } from "./schema"
+
+const files = (disableClaudeCodePrompt: boolean) => [
+  "AGENTS.md",
+  ...(disableClaudeCodePrompt ? [] : ["CLAUDE.md"]),
+  "CONTEXT.md", // deprecated
+]
+
+function extract(messages: MessageV2.WithParts[]) {
+  const paths = new Set<string>()
+  for (const msg of messages) {
+    for (const part of msg.parts) {
+      if (part.type === "tool" && part.tool === "read" && part.state.status === "completed") {
+        if (part.state.time.compacted) continue
+        const loaded = part.state.metadata?.loaded
+        if (!loaded || !Array.isArray(loaded)) continue
+        for (const p of loaded) {
+          if (typeof p === "string") paths.add(p)
+        }
+      }
+    }
+  }
+  return paths
+}
+
+export interface Interface {
+  readonly clear: (messageID: MessageID) => Effect.Effect<void>
+  readonly systemPaths: () => Effect.Effect<Set<string>, AppFileSystem.Error>
+  readonly system: () => Effect.Effect<string[], AppFileSystem.Error>
+  readonly find: (dir: string) => Effect.Effect<string | undefined, AppFileSystem.Error>
+  readonly resolve: (
+    messages: MessageV2.WithParts[],
+    filepath: string,
+    messageID: MessageID,
+  ) => Effect.Effect<{ filepath: string; content: string }[], AppFileSystem.Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Instruction") {}
+
+export const layer: Layer.Layer<
+  Service,
+  never,
+  AppFileSystem.Service | Config.Service | Global.Service | HttpClient.HttpClient | RuntimeFlags.Service
+> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const cfg = yield* Config.Service
+    const fs = yield* AppFileSystem.Service
+    const global = yield* Global.Service
+    const flags = yield* RuntimeFlags.Service
+    const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
+    const globalFiles = [
+      path.join(global.config, "AGENTS.md"),
+      ...(!flags.disableClaudeCodePrompt ? [path.join(global.home, ".claude", "CLAUDE.md")] : []),
+    ]
+    const instructionFiles = files(flags.disableClaudeCodePrompt)
+
+    const state = yield* InstanceState.make(
+      Effect.fn("Instruction.state")(() =>
+        Effect.succeed({
+          // Track which instruction files have already been attached for a given assistant message.
+          claims: new Map<MessageID, Set<string>>(),
+        }),
+      ),
+    )
+
+    const relative = Effect.fnUntraced(function* (instruction: string) {
+      const ctx = yield* InstanceState.context
+      if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
+        return yield* fs
+          .globUp(instruction, ctx.directory, ctx.worktree)
+          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      }
+      return yield* fs
+        .globUp(instruction, global.config, global.config)
+        .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+    })
+
+    const read = Effect.fnUntraced(function* (filepath: string) {
+      return yield* fs.readFileString(filepath).pipe(Effect.catch(() => Effect.succeed("")))
+    })
+
+    const fetch = Effect.fnUntraced(function* (url: string) {
+      const res = yield* http.execute(HttpClientRequest.get(url)).pipe(
+        Effect.timeout(5000),
+        Effect.catch(() => Effect.succeed(null)),
+      )
+      if (!res) return ""
+      const body = yield* res.arrayBuffer.pipe(Effect.catch(() => Effect.succeed(new ArrayBuffer(0))))
+      return new TextDecoder().decode(body)
+    })
+
+    const clear = Effect.fn("Instruction.clear")(function* (messageID: MessageID) {
+      const s = yield* InstanceState.get(state)
+      s.claims.delete(messageID)
+    })
+
+    const systemPaths = Effect.fn("Instruction.systemPaths")(function* () {
+      const config = yield* cfg.get()
+      const ctx = yield* InstanceState.context
+      const paths = new Set<string>()
+
+      for (const file of globalFiles) {
+        if (yield* fs.existsSafe(file)) {
+          paths.add(path.resolve(file))
+          break
+        }
+      }
+
+      // The first project-level match wins so we don't stack AGENTS.md/CLAUDE.md from every ancestor.
+      if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
+        for (const file of instructionFiles) {
+          const matches = yield* fs
+            .findUp(file, ctx.directory, ctx.worktree)
+            .pipe(Effect.catch(() => Effect.succeed([])))
+          if (matches.length > 0) {
+            matches.forEach((item) => paths.add(path.resolve(item)))
+            break
+          }
+        }
+      }
+
+      if (config.instructions) {
+        for (const raw of config.instructions) {
+          if (raw.startsWith("https://") || raw.startsWith("http://")) continue
+          const instruction = raw.startsWith("~/") ? path.join(global.home, raw.slice(2)) : raw
+          const matches = yield* (
+            path.isAbsolute(instruction)
+              ? fs.glob(path.basename(instruction), {
+                  cwd: path.dirname(instruction),
+                  absolute: true,
+                  include: "file",
+                })
+              : relative(instruction)
+          ).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+          matches.forEach((item) => paths.add(path.resolve(item)))
+        }
+      }
+
+      return paths
+    })
+
+    const system = Effect.fn("Instruction.system")(function* () {
+      const config = yield* cfg.get()
+      const paths = yield* systemPaths()
+      const urls = (config.instructions ?? []).filter(
+        (item) => item.startsWith("https://") || item.startsWith("http://"),
+      )
+
+      const files = yield* Effect.forEach(Array.from(paths), read, { concurrency: 8 })
+      const remote = yield* Effect.forEach(urls, fetch, { concurrency: 4 })
+
+      return [
+        ...Array.from(paths).flatMap((item, i) => (files[i] ? [`Instructions from: ${item}\n${files[i]}`] : [])),
+        ...urls.flatMap((item, i) => (remote[i] ? [`Instructions from: ${item}\n${remote[i]}`] : [])),
+      ]
+    })
+
+    const find = Effect.fn("Instruction.find")(function* (dir: string) {
+      for (const file of instructionFiles) {
+        const filepath = path.resolve(path.join(dir, file))
+        if (yield* fs.existsSafe(filepath)) return filepath
+      }
+      return undefined
+    })
+
+    const resolve = Effect.fn("Instruction.resolve")(function* (
+      messages: MessageV2.WithParts[],
+      filepath: string,
+      messageID: MessageID,
+    ) {
+      const sys = yield* systemPaths()
+      const already = extract(messages)
+      const results: { filepath: string; content: string }[] = []
+      const s = yield* InstanceState.get(state)
+      const root = path.resolve(yield* InstanceState.directory)
+
+      const target = path.resolve(filepath)
+      let current = path.dirname(target)
+
+      // Walk upward from the file being read and attach nearby instruction files once per message.
+      while (current.startsWith(root) && current !== root) {
+        const found = yield* find(current)
+        if (!found || found === target || sys.has(found) || already.has(found)) {
+          current = path.dirname(current)
+          continue
+        }
+
+        let set = s.claims.get(messageID)
+        if (!set) {
+          set = new Set()
+          s.claims.set(messageID, set)
+        }
+        if (set.has(found)) {
+          current = path.dirname(current)
+          continue
+        }
+
+        set.add(found)
+        const content = yield* read(found)
+        if (content) {
+          results.push({ filepath: found, content: `Instructions from: ${found}\n${content}` })
+        }
+
+        current = path.dirname(current)
+      }
+
+      return results
+    })
+
+    return Service.of({ clear, systemPaths, system, find, resolve })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(Global.layer),
+  Layer.provide(AppFileSystem.defaultLayer),
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(RuntimeFlags.defaultLayer),
+)
+
+export function loaded(messages: MessageV2.WithParts[]) {
+  return extract(messages)
+}
+
+export * as Instruction from "./instruction"

package/src/engine/session/instruction_loader.ts

@@ -0,0 +1,54 @@
+/**
+ * Instruction file loader — ported from OpenCode's session/instruction.ts
+ * Scans for AGENTS.md, CLAUDE.md, OPENCODE.md walking up from the working directory.
+ */
+
+import * as fs from "fs/promises";
+import * as path from "path";
+
+const INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md", "OPENCODE.md", ".opencode/instructions.md"];
+
+export async function loadInstructionFiles(worktree: string): Promise<string> {
+  const found: string[] = [];
+
+  // Walk up from worktree looking for instruction files
+  let dir = worktree;
+  const visited = new Set<string>();
+
+  while (dir && !visited.has(dir)) {
+    visited.add(dir);
+    for (const filename of INSTRUCTION_FILES) {
+      const filePath = path.join(dir, filename);
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        if (content.trim()) {
+          found.push(`<!-- Instructions from ${filePath} -->\n${content.trim()}`);
+        }
+      } catch {
+        // File doesn't exist — skip
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Also check global config dirs
+  const globalDirs = [
+    path.join(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode"),
+    path.join(process.env.HOME || process.env.USERPROFILE || "", ".opencode"),
+  ];
+  for (const globalDir of globalDirs) {
+    for (const filename of INSTRUCTION_FILES) {
+      const filePath = path.join(globalDir, filename);
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        if (content.trim()) {
+          found.push(`<!-- Global instructions from ${filePath} -->\n${content.trim()}`);
+        }
+      } catch {}
+    }
+  }
+
+  return found.join("\n\n");
+}