@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-kg06axw8.js

@@ -0,0 +1,162 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/state.ts
+var exports_state = {};
+__export(exports_state, {
+  State: () => exports_state,
+  batch: () => batch2,
+  create: () => create3,
+  group: () => group2,
+  inherit: () => inherit2,
+  reconcile: () => reconcile2,
+  shutdown: () => shutdown2
+});
+import { Cause, Context, Effect, Exit, Fiber, Scope } from "effect";
+var CurrentGroup = Context.Reference("@opencode/State/CurrentGroup", {
+  defaultValue: () => {
+    return;
+  }
+});
+function group2(report) {
+  const group = { failed: false, registrations: new Set, report };
+  return (effect) => Effect.provideService(effect, CurrentGroup, group);
+}
+function disable(group, failure) {
+  if (group.failed)
+    return;
+  group.failed = true;
+  const notifications = new Set;
+  for (const registration of group.registrations) {
+    registration.remove();
+    notifications.add(registration.notify);
+  }
+  group.report(failure, Effect.forEach(notifications, (notify) => notify, { discard: true }));
+}
+var CurrentBatch = Context.Reference("@opencode/State/CurrentBatch", {
+  defaultValue: () => {
+    return;
+  }
+});
+function batch2(effect) {
+  return run(effect, false);
+}
+function shutdown2(effect) {
+  return run(effect, true);
+}
+function run(effect, shutdown) {
+  return Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const current = yield* CurrentBatch;
+    if (current?.active && !shutdown)
+      return yield* restore(effect);
+    const batch = { active: true, shutdown, notifications: new Set };
+    const exit = yield* restore(effect.pipe(Effect.provideService(CurrentBatch, batch))).pipe(Effect.exit);
+    batch.active = false;
+    const notifications = yield* Effect.forEach(batch.notifications, (notify) => restore(notify).pipe(Effect.exit));
+    yield* Exit.asVoidAll([exit, ...notifications]);
+    return yield* exit;
+  }));
+}
+function reconcile2(root, fork, work) {
+  return Effect.gen(function* () {
+    const exit = yield* Fiber.await(fork(work()));
+    if (Exit.isFailure(exit) && root.state._tag === "Closed" && Cause.hasInterruptsOnly(exit.cause))
+      return;
+    yield* exit;
+  });
+}
+var inherit2 = Effect.fnUntraced(function* () {
+  const batch = yield* CurrentBatch;
+  return (effect) => Effect.provideService(effect, CurrentBatch, batch);
+});
+function create3(options) {
+  let state = options.initial();
+  const transforms = new Set;
+  let dirty = false;
+  let closed = false;
+  let version = 0;
+  const invalidate = () => {
+    dirty = true;
+    version++;
+  };
+  const get = () => {
+    if (closed || !dirty)
+      return state;
+    while (true) {
+      const started = version;
+      const next = options.initial();
+      const editor = options.editor(next);
+      for (const transform of transforms) {
+        try {
+          transform.run(editor);
+        } catch (cause) {
+          if (!transform.group)
+            throw cause;
+          disable(transform.group, { state: options.name ?? "anonymous", cause });
+        }
+        if (version !== started)
+          break;
+      }
+      if (version !== started)
+        continue;
+      state = next;
+      dirty = false;
+      return state;
+    }
+  };
+  const notify = Effect.gen(function* () {
+    if (closed)
+      return;
+    const value = get();
+    if (options.notify)
+      yield* options.notify(value);
+  }).pipe(Effect.withSpan("State.notify"));
+  const changed = Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    if (closed)
+      return;
+    invalidate();
+    const batch = yield* CurrentBatch;
+    if (batch?.active) {
+      if (batch.shutdown) {
+        closed = true;
+        return;
+      }
+      batch.notifications.add(notify);
+      return;
+    }
+    yield* restore(notify);
+  }));
+  return {
+    get,
+    transform: Effect.fn("State.transform")(function* (update) {
+      yield* Effect.annotateCurrentSpan("state", options.name ?? "anonymous");
+      const scope = yield* Scope.Scope;
+      const group = yield* CurrentGroup;
+      if (group?.failed)
+        return { dispose: Effect.void };
+      return yield* Effect.uninterruptible(Effect.gen(function* () {
+        const transform = { run: update, group };
+        const registration = {
+          remove: () => {
+            if (!transforms.delete(transform))
+              return false;
+            group?.registrations.delete(registration);
+            invalidate();
+            return true;
+          },
+          notify: changed
+        };
+        const dispose = Effect.uninterruptible(Effect.suspend(() => registration.remove() ? changed : Effect.void));
+        transforms.add(transform);
+        group?.registrations.add(registration);
+        yield* Scope.addFinalizer(scope, dispose);
+        yield* changed;
+        return { dispose };
+      }));
+    }),
+    reload: () => changed
+  };
+}
+
+export { group2, batch2, shutdown2, reconcile2, inherit2, create3, exports_state };

package/dist/chunks/repository-kkdm9ajw.js

@@ -0,0 +1,59 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/discovery.ts
+var exports_discovery2 = {};
+__export(exports_discovery2, {
+  ConfigDiscovery: () => exports_discovery2,
+  discover: () => discover3,
+  names: () => names4
+});
+import path from "path";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var names4 = ["opencode.json", "opencode.jsonc"];
+var discover3 = Effect.fn("ConfigDiscovery.discover")(function* (options) {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const location = yield* Service66;
+  const globalDirectory = AbsolutePath2.make(global.config);
+  const globalAgentsDirectory = AbsolutePath2.make(path.join(global.home, ".agents"));
+  const globalClaudeDirectory = AbsolutePath2.make(path.join(global.home, ".claude"));
+  const globalRoots = yield* Effect.forEach([globalDirectory, globalClaudeDirectory, globalAgentsDirectory], (item) => fs.resolve(item));
+  const directories = (yield* fs.resolve(location.directory)) === globalRoots[0] || options?.project === false ? [] : yield* fs.up({ targets: ["."], start: location.directory }).pipe(Effect.orDie);
+  const discovered = yield* Effect.forEach(directories, (directory) => Effect.gen(function* () {
+    const parent = yield* fs.resolve(directory);
+    return yield* Effect.forEach([".claude", ".agents", ".opencode", ...names4.toReversed()], (name) => fs.resolve(path.join(parent, name)).pipe(Effect.map((resolved) => ({ item: AbsolutePath2.make(path.join(directory, name)), resolved }))));
+  })).pipe(Effect.map((items) => items.flat()), Effect.orDie);
+  const globalEnabled = options?.global !== false;
+  const globalFiles = yield* Effect.forEach(names4, (name) => fs.resolve(path.join(globalDirectory, name)));
+  const visible = discovered.filter(({ resolved }) => globalEnabled ? !globalRoots.includes(resolved) && !globalFiles.includes(resolved) : !globalRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))).map(({ item }) => item);
+  return {
+    global: globalEnabled ? globalDirectory : undefined,
+    explicit: options?.file ? AbsolutePath2.make(path.resolve(options.file)) : undefined,
+    direct: visible.filter((item) => ![".agents", ".claude", ".opencode"].includes(path.basename(item))).toReversed(),
+    project: yield* Effect.forEach(visible.filter((item) => path.basename(item) === ".opencode").toReversed(), (directory) => fs.isDir(directory).pipe(Effect.map((present) => ({ path: directory, present })))),
+    claude: [
+      ...new Set([
+        ...globalEnabled ? [globalClaudeDirectory] : [],
+        ...visible.filter((item) => path.basename(item) === ".claude").toReversed()
+      ])
+    ],
+    agents: [
+      ...new Set([
+        ...globalEnabled ? [globalAgentsDirectory] : [],
+        ...visible.filter((item) => path.basename(item) === ".agents").toReversed()
+      ])
+    ]
+  };
+});
+
+export { names4, discover3, exports_discovery2 };

package/dist/chunks/repository-ksjan0t5.js

@@ -0,0 +1,56 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  KVTable2
+} from "./repository-3hepkmqq.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/kv.ts
+var exports_kv = {};
+__export(exports_kv, {
+  KV: () => exports_kv,
+  Service: () => Service63,
+  node: () => node67
+});
+import { and, asc, eq, gt, gte, lt } from "drizzle-orm";
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+class Service63 extends Context.Service()("@opencode/KV") {
+}
+var layer = Layer.effect(Service63, Effect.gen(function* () {
+  const db = (yield* Service79).db;
+  return Service63.of({
+    get: Effect.fn("KV.get")(function* (key) {
+      return (yield* db.select({ value: KVTable2.value }).from(KVTable2).where(eq(KVTable2.key, key)).get().pipe(Effect.orDie))?.value;
+    }),
+    set: Effect.fn("KV.set")(function* (key, value) {
+      yield* db.insert(KVTable2).values({ key, value }).onConflictDoUpdate({ target: KVTable2.key, set: { value, time_updated: Date.now() } }).run().pipe(Effect.orDie);
+    }),
+    remove: Effect.fn("KV.remove")(function* (key) {
+      yield* db.delete(KVTable2).where(eq(KVTable2.key, key)).run().pipe(Effect.orDie);
+    }),
+    scan: Effect.fn("KV.scan")(function* (options) {
+      const limit = Number.isNaN(options.limit) ? 100 : Math.min(Math.max(Math.floor(options.limit ?? 100), 1), 1000);
+      const end = prefixEnd(options.prefix);
+      const rows = yield* db.select({ key: KVTable2.key, value: KVTable2.value }).from(KVTable2).where(and(options.prefix === "" ? undefined : gte(KVTable2.key, options.prefix), end === undefined ? undefined : lt(KVTable2.key, end), options.after === undefined ? undefined : gt(KVTable2.key, options.after))).orderBy(asc(KVTable2.key)).limit(limit + 1).all().pipe(Effect.orDie);
+      const entries = rows.slice(0, limit);
+      if (rows.length <= limit)
+        return { entries };
+      return { entries, next: entries[entries.length - 1].key };
+    })
+  });
+}));
+function prefixEnd(prefix) {
+  const points = Array.from(prefix);
+  const index = points.findLastIndex((value) => value.codePointAt(0) < 1114111);
+  if (index < 0)
+    return;
+  return `${points.slice(0, index).join("")}${String.fromCodePoint(points[index].codePointAt(0) + 1)}`;
+}
+var node67 = makeGlobalNode({ service: Service63, layer, deps: [node84] });
+
+export { Service63, node67, exports_kv };

package/dist/chunks/repository-ky16kd9n.js

@@ -0,0 +1,148 @@
+import {
+  cleanup3
+} from "./repository-gd4qta3r.js";
+import {
+  ascending2
+} from "./repository-tvtrv512.js";
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool-output.ts
+var exports_tool_output2 = {};
+__export(exports_tool_output2, {
+  DIRECTORY: () => DIRECTORY3,
+  MAX_BYTES: () => MAX_BYTES2,
+  MAX_LINES: () => MAX_LINES2,
+  RETENTION: () => RETENTION3,
+  Service: () => Service64,
+  ToolOutput: () => exports_tool_output2,
+  node: () => node68
+});
+import path from "path";
+import { Context, Duration, Effect, Layer, Schedule } from "effect";
+import { makeGlobalNode, makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var MAX_LINES2 = 2000;
+var MAX_BYTES2 = 50 * 1024;
+var RETENTION3 = Duration.days(7);
+var DIRECTORY3 = "tool-output";
+
+class Service64 extends Context.Service()("@opencode/ToolOutput") {
+}
+var cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs, directory) {
+  const entries = yield* fs.readDirectory(directory).pipe(Effect.map((entries) => entries.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))), Effect.orElseSucceed(() => []));
+  yield* cleanup3(fs, entries.map((entry) => path.join(directory, entry)), RETENTION3);
+});
+var layer = Layer.effect(Service64, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const directory = path.join(global.data, DIRECTORY3);
+  const state = create3({
+    name: "tool-output",
+    initial: () => ({ maxLines: MAX_LINES2, maxBytes: MAX_BYTES2 }),
+    editor: (editor) => ({
+      configure: (limits) => {
+        if (limits.maxLines !== undefined)
+          editor.maxLines = limits.maxLines;
+        if (limits.maxBytes !== undefined)
+          editor.maxBytes = limits.maxBytes;
+      }
+    })
+  });
+  const truncate = Effect.fnUntraced(function* (result) {
+    if (result.metadata?.truncated !== undefined)
+      return result;
+    const content = result.content;
+    const text = content.flatMap((item) => item.type === "text" ? [item.text] : []).join(`
+`);
+    const limits = state.get();
+    const lines = text.split(`
+`);
+    if (text.endsWith(`
+`))
+      lines.pop();
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= limits.maxLines && totalBytes <= limits.maxBytes)
+      return { ...result, metadata: { ...result.metadata, truncated: false } };
+    const kept = [];
+    let bytes = 0;
+    let hitBytes = false;
+    for (const line of lines.slice(0, limits.maxLines)) {
+      const size = Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0);
+      if (bytes + size > limits.maxBytes) {
+        hitBytes = true;
+        break;
+      }
+      kept.push(line);
+      bytes += size;
+    }
+    if (!hitBytes && kept.length === lines.length && totalBytes > bytes)
+      hitBytes = true;
+    const removed = hitBytes ? totalBytes - bytes : lines.length - kept.length;
+    const unit = hitBytes ? removed === 1 ? "byte" : "bytes" : removed === 1 ? "line" : "lines";
+    const file = path.join(directory, ascending2("tool"));
+    yield* fs.ensureDir(directory).pipe(Effect.orDie);
+    yield* fs.writeFileString(file, text).pipe(Effect.orDie);
+    const marker = `... ${removed} ${unit} truncated; full content saved to ${file} ...`;
+    const bounded = [];
+    let remaining = kept.join(`
+`).length;
+    let seenText = false;
+    let marked = false;
+    for (const item of content) {
+      if (item.type === "file") {
+        bounded.push(item);
+        continue;
+      }
+      if (seenText && remaining > 0)
+        remaining--;
+      seenText = true;
+      if (remaining >= item.text.length) {
+        bounded.push(item);
+        remaining -= item.text.length;
+        continue;
+      }
+      if (remaining > 0)
+        bounded.push({ ...item, text: item.text.slice(0, remaining) });
+      if (!marked)
+        bounded.push({ type: "text", text: marker });
+      remaining = 0;
+      marked = true;
+    }
+    if (!marked)
+      bounded.push({ type: "text", text: marker });
+    return {
+      ...result,
+      content: bounded,
+      metadata: { ...result.metadata, truncated: true, outputPath: file }
+    };
+  });
+  return Service64.of({
+    transform: state.transform,
+    reload: state.reload,
+    truncate,
+    cleanup: () => cleanup(fs, directory)
+  });
+}));
+var cleanupLayer = Layer.effectDiscard(Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  yield* cleanup(fs, path.join(global.data, DIRECTORY3)).pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped);
+}));
+var cleanupNode = makeGlobalNode({
+  name: "tool-output-cleanup",
+  layer: cleanupLayer,
+  deps: [FSUtil.node, Global.node]
+});
+var node68 = makeLocationNode({
+  service: Service64,
+  layer,
+  deps: [FSUtil.node, Global.node, cleanupNode]
+});
+
+export { MAX_LINES2, MAX_BYTES2, RETENTION3, DIRECTORY3, Service64, node68, exports_tool_output2 };

package/dist/chunks/repository-m2d0j7c0.js

@@ -0,0 +1,155 @@
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/skill/discovery.ts
+var exports_discovery = {};
+__export(exports_discovery, {
+  Service: () => Service7,
+  SkillDiscovery: () => exports_discovery,
+  node: () => node9
+});
+import path from "path";
+import { Context, Effect, Layer, Schedule, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { Hash } from "@opencode/util/hash";
+var skillConcurrency = 4;
+var fileConcurrency = 8;
+function isSafeSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\x00");
+}
+function isSafeRelativePath(value) {
+  const segments = value.split("/");
+  return value.length > 0 && !value.includes("\\") && !value.includes("\x00") && !value.includes("?") && !value.includes("#") && !URL.canParse(value) && !path.posix.isAbsolute(value) && !path.win32.isAbsolute(value) && segments.every((segment) => {
+    try {
+      return isSafeSegment(decodeURIComponent(segment));
+    } catch {
+      return false;
+    }
+  });
+}
+
+class IndexSkill extends Schema.Class("SkillDiscovery.IndexSkill")({
+  name: Schema.String,
+  version: Schema.optional(Schema.String),
+  files: Schema.Array(Schema.String)
+}) {
+}
+
+class Index extends Schema.Class("SkillDiscovery.Index")({
+  skills: Schema.Array(IndexSkill)
+}) {
+}
+
+class Service7 extends Context.Service()("@opencode/SkillDiscovery") {
+}
+var layer = Layer.effect(Service7, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const http = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+    retryOn: "errors-and-responses",
+    times: 2,
+    schedule: Schedule.exponential(200).pipe(Schedule.jittered)
+  }), HttpClient.filterStatusOk);
+  const download = Effect.fn("SkillDiscovery.download")(function* (url, destination) {
+    if (yield* fs.exists(destination).pipe(Effect.orDie))
+      return true;
+    return yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.flatMap((body) => fs.writeWithDirs(destination, new Uint8Array(body))), Effect.as(true), Effect.catch((error) => Effect.logError("failed to download skill file", { url, error }).pipe(Effect.as(false))));
+  });
+  return Service7.of({
+    pull: Effect.fn("SkillDiscovery.pull")(function* (url) {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      const source = new URL(base);
+      const index = new URL("index.json", source).href;
+      const data = yield* HttpClientRequest.get(index).pipe(HttpClientRequest.acceptJson, http.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)), Effect.catch((error) => Effect.logError("failed to fetch skill index", { url: index, error }).pipe(Effect.as(undefined))));
+      if (!data)
+        return [];
+      const sourceRoot = path.resolve(global.cache, "skills", Hash.fast(base));
+      return yield* Effect.forEach(data.skills.flatMap((skill) => {
+        if (!isSafeSegment(skill.name)) {
+          return [];
+        }
+        if (!skill.files.includes("SKILL.md") && !skill.files.includes(`${skill.name}.md`)) {
+          return [];
+        }
+        const root = path.resolve(sourceRoot, skill.name);
+        if (!FSUtil.contains(sourceRoot, root) || root === sourceRoot) {
+          return [];
+        }
+        const skillUrl = new URL(`${encodeURIComponent(skill.name)}/`, source);
+        const versionFile = path.join(root, ".opencode-version");
+        const files = skill.files.map((file) => {
+          if (!isSafeRelativePath(file))
+            return;
+          let resource;
+          try {
+            resource = new URL(file, skillUrl);
+          } catch {
+            return;
+          }
+          if (resource.origin !== source.origin)
+            return;
+          const destination = path.resolve(root, file);
+          if (!FSUtil.contains(root, destination) || destination === root)
+            return;
+          return {
+            url: resource.href,
+            destination,
+            file
+          };
+        });
+        if (!files.every((file) => file !== undefined))
+          return [];
+        return [{ skill, root, versionFile, files }];
+      }), ({ skill, root, versionFile, files }) => Effect.gen(function* () {
+        const version = skill.version;
+        const current = version === undefined ? undefined : yield* fs.readFileStringSafe(versionFile).pipe(Effect.orElseSucceed(() => {
+          return;
+        }));
+        if (version === undefined || current === version) {
+          yield* Effect.forEach(files, (file) => download(file.url, file.destination), {
+            concurrency: fileConcurrency,
+            discard: true
+          });
+        } else {
+          const token = crypto.randomUUID();
+          const staging = `${root}.tmp-${token}`;
+          const backup = `${root}.old-${token}`;
+          yield* Effect.gen(function* () {
+            const downloaded = yield* Effect.forEach(files, (file) => download(file.url, path.resolve(staging, file.file)), { concurrency: fileConcurrency });
+            if (!downloaded.every(Boolean))
+              return;
+            const exists = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
+            if (!exists)
+              return;
+            yield* fs.writeFileString(path.join(staging, ".opencode-version"), version);
+            yield* Effect.uninterruptible(Effect.gen(function* () {
+              const cached = yield* fs.exists(root).pipe(Effect.orDie);
+              if (cached)
+                yield* fs.rename(root, backup);
+              yield* fs.rename(staging, root).pipe(Effect.catch((error) => Effect.gen(function* () {
+                if (cached)
+                  yield* fs.rename(backup, root).pipe(Effect.ignore);
+                return yield* Effect.fail(error);
+              })));
+              if (cached)
+                yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore);
+            }));
+          }).pipe(Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })), Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
+        }
+        const exists = (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(root, `${skill.name}.md`)).pipe(Effect.orDie));
+        return exists ? [AbsolutePath2.make(root)] : [];
+      }), { concurrency: skillConcurrency }).pipe(Effect.map((directories) => directories.flat()));
+    })
+  });
+}));
+var node9 = makeGlobalNode({ service: Service7, layer, deps: [httpClient, FSUtil.node, Global.node] });
+
+export { Service7, node9, exports_discovery };