@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-seps633m.js

@@ -0,0 +1,207 @@
+import {
+  ID9,
+  Service61
+} from "./repository-b5n11jz6.js";
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  Service44
+} from "./repository-smnv2tch.js";
+import {
+  Service57,
+  args2
+} from "./repository-3ke3s58r.js";
+import {
+  Service26
+} from "./repository-51cmmk6m.js";
+import {
+  make10
+} from "./repository-2cgm8dc1.js";
+import {
+  parseOption2
+} from "./repository-5daktx2q.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/command.ts
+var exports_command = {};
+__export(exports_command, {
+  ConfigCommandPlugin: () => exports_command,
+  Plugin: () => Plugin18
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { ConfigCommand } from "@opencode/schema/config/command";
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";
+import { AppProcess } from "@opencode/util/process";
+import path from "path";
+import { Effect, Option, PubSub, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { FSUtil } from "@opencode/util/fs-util";
+var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
+var Plugin18 = define({
+  id: "opencode.config.command",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service44;
+    const fs = yield* FSUtil.Service;
+    const loadEntry = Effect.fnUntraced(function* (entry) {
+      if (entry.type === "document")
+        return [{ commands: entry.info.commands }];
+      if (entry.type !== "directory")
+        return [];
+      const commands = yield* loadDirectory(fs, entry.path);
+      return [{ commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }];
+    });
+    const location = yield* Service66;
+    const processes = yield* AppProcess.Service;
+    const shell = yield* Service57;
+    const sessions = yield* Service26;
+    const agents = yield* Service61;
+    const subagents = yield* make10;
+    const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.command.reload()));
+    const changes = yield* PubSub.sliding(1);
+    const notify = () => PubSub.publish(changes, undefined);
+    yield* config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    const updates = yield* PubSub.subscribe(changes);
+    yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.command.transform((editor) => {
+      for (const document of loaded.documents) {
+        for (const [name, command] of Object.entries(document.commands ?? {})) {
+          const subagent = command.subagent ?? command.subtask;
+          editor.add({
+            name,
+            description: command.description,
+            execute: (input) => Effect.gen(function* () {
+              const agent = command.agent === undefined ? undefined : ID9.make(command.agent);
+              const commandAgent = agent === undefined ? undefined : (yield* ctx.agent.get({ agentID: agent })).data;
+              const model = command.model === undefined ? commandAgent?.model : {
+                id: Model.ID.make(command.model.model),
+                providerID: Provider.ID.make(command.model.providerID),
+                ...command.model.variant === undefined ? {} : { variant: Model.VariantID.make(command.model.variant) }
+              };
+              const text = yield* evaluateTemplate(command.template, input.prompt.text, {
+                location,
+                processes,
+                shell
+              });
+              if (subagent ?? commandAgent?.mode === "subagent") {
+                const parent = yield* sessions.get(input.sessionID);
+                const selected = yield* agents.select(agent ?? parent.agent);
+                const child = yield* sessions.create({
+                  parentID: parent.id,
+                  title: command.description ?? name,
+                  agent: selected.id,
+                  model: model ?? selected.info?.model ?? parent.model
+                });
+                yield* sessions.prompt({
+                  ...input.prompt,
+                  sessionID: child.id,
+                  text: ["You are a subagent spawned by another session.", text].join(`
+`),
+                  resume: false
+                });
+                const recovery = {
+                  kind: "subagent",
+                  parentSessionID: parent.id,
+                  childSessionID: child.id,
+                  agent: selected.id,
+                  description: command.description ?? name
+                };
+                yield* subagents.start(recovery);
+                yield* subagents.background(recovery);
+                return;
+              }
+              if (agent !== undefined) {
+                const session = yield* ctx.session.get({ sessionID: input.sessionID });
+                if (session.agent !== agent)
+                  yield* ctx.session.switchAgent({ sessionID: input.sessionID, agent });
+              }
+              if (model !== undefined)
+                yield* ctx.session.switchModel({ sessionID: input.sessionID, model });
+              yield* ctx.session.prompt({
+                ...input.prompt,
+                sessionID: input.sessionID,
+                text,
+                delivery: input.delivery
+              });
+            }).pipe(Effect.asVoid)
+          });
+        }
+      }
+    });
+  })
+});
+var sourceDirectories = ["command", "commands"];
+function isCommandSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function loadDirectory(fs, directory) {
+  return Effect.gen(function* () {
+    const files = yield* fs.scan("{command,commands}/**/*.md", { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.orElseSucceed(() => []));
+    return yield* Effect.forEach(files.toSorted(), (filepath) => fs.readFileStringSafe(filepath).pipe(Effect.map((content) => content === undefined ? undefined : decode(directory, filepath, content)), Effect.orElseSucceed(() => {
+      return;
+    }))).pipe(Effect.map((commands) => commands.filter((command) => command !== undefined)));
+  });
+}
+function decode(directory, filepath, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return;
+  const info = Option.getOrUndefined(decodeCommand({ ...markdown.data, template: markdown.content.trim() }));
+  if (!info)
+    return;
+  return {
+    name: path.relative(directory, filepath).replaceAll("\\", "/").replace(/^(command|commands)\//, "").replace(/\.md$/, ""),
+    info
+  };
+}
+function evaluateTemplate(template, input, services) {
+  return Effect.gen(function* () {
+    const args = parseArguments(input);
+    const placeholders = template.match(placeholderRegex) ?? [];
+    const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))));
+    const expanded = template.replaceAll(placeholderRegex, (_, index) => {
+      const position = Number(index);
+      const argIndex = position - 1;
+      if (argIndex >= args.length)
+        return "";
+      if (position === last)
+        return args.slice(argIndex).join(" ");
+      return args[argIndex];
+    });
+    const withArguments = expanded.replaceAll("$ARGUMENTS", () => input);
+    const text = placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim() ? `${withArguments}
+
+${input}`.trim() : withArguments.trim();
+    const matches = Array.from(text.matchAll(shellRegex));
+    if (matches.length === 0)
+      return text;
+    const shell = yield* services.shell.resolve({ priority: "config" });
+    const outputs = yield* Effect.forEach(matches, (match) => {
+      const source = match[1] ?? "";
+      return services.processes.run(ChildProcess.make(shell, args2(shell, source), {
+        cwd: services.location.directory,
+        stdin: "ignore"
+      }), { combineOutput: true }).pipe(Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")), Effect.mapError((error) => new Error(`Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`)));
+    }, { concurrency: 2 });
+    const iterator = outputs[Symbol.iterator]();
+    return text.replace(shellRegex, () => iterator.next().value ?? "");
+  });
+}
+function parseArguments(input) {
+  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""));
+}
+var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
+var placeholderRegex = /\$(\d+)/g;
+var quoteTrimRegex = /^["']|["']$/g;
+var shellRegex = /!`([^`]+)`/g;
+
+export { Plugin18, exports_command };

package/dist/chunks/repository-sgk3431w.js

@@ -0,0 +1,140 @@
+import {
+  Service45,
+  node50
+} from "./repository-shg3amz7.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Service44,
+  node49
+} from "./repository-smnv2tch.js";
+import {
+  names2,
+  discover2
+} from "./repository-zxq2ej10.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/plugin/source.ts
+var exports_source = {};
+__export(exports_source, {
+  ConfigPluginSource: () => exports_source,
+  Service: () => Service2,
+  empty: () => empty2,
+  layer: () => layer4,
+  node: () => node4
+});
+import { FSUtil } from "@opencode/util/fs-util";
+import { Host } from "@opencode/plugin/host";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Option, PubSub, Stream } from "effect";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+class Service2 extends Context.Service()("@opencode/ConfigPluginSource") {
+}
+var layer4 = Layer.effect(Service2, Effect.gen(function* () {
+  const config = yield* Service44;
+  const watcher = yield* Service45;
+  const fs = yield* FSUtil.Service;
+  const location = yield* Service66;
+  const configuredChanges = yield* PubSub.unbounded();
+  const watched = new Set;
+  const watchConfiguredSources = Effect.fn("ConfigPluginSource.watchConfiguredSources")(function* (entries, operations) {
+    for (const operation of operations) {
+      if (operation.type !== "add" || !path.isAbsolute(operation.target))
+        continue;
+      if (watched.has(operation.target))
+        continue;
+      if (isPluginSource(entries, operation.target))
+        continue;
+      watched.add(operation.target);
+      const updates = yield* watcher.subscribe({
+        path: operation.target,
+        type: (yield* fs.isDir(operation.target)) ? "directory" : "file"
+      });
+      yield* updates.pipe(Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)), Effect.catchCause((cause) => Effect.logError("configured plugin watch failed", { target: operation.target, cause })), Effect.forkScoped({ startImmediately: true }));
+    }
+  });
+  return Service2.of({
+    operations: Effect.fn("ConfigPluginSource.operations")(function* () {
+      const entries = yield* config.entries();
+      const operations = yield* scan(fs, location, entries);
+      yield* watchConfiguredSources(entries, operations);
+      return operations;
+    }),
+    changes: () => Stream.merge(config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isPluginSource(entries, update.path))), Stream.map(() => {
+      return;
+    })), Stream.fromPubSub(configuredChanges))
+  });
+}));
+var node4 = makeLocationNode({
+  service: Service2,
+  layer: layer4,
+  deps: [node49, FSUtil.node, node50, node70]
+});
+var empty2 = makeLocationNode({
+  service: Service2,
+  layer: Layer.succeed(Service2, Service2.of({
+    operations: () => Effect.succeed([]),
+    changes: () => Stream.never
+  })),
+  deps: []
+});
+function parse(input) {
+  if (typeof input !== "string") {
+    return { type: "add", target: input.package, options: input.options ?? {} };
+  }
+  if (!input.startsWith("-"))
+    return { type: "add", target: input, options: {} };
+  if (input.length === 1)
+    throw new Error("Plugin remove operation requires a target");
+  return { type: "remove", target: input.slice(1) };
+}
+var scan = Effect.fn("ConfigPluginSource.scan")(function* (fs, location, entries) {
+  const discovered = yield* Effect.forEach(entries.filter((entry) => entry.type === "directory"), (entry) => discover2(fs, entry.path).pipe(Effect.map((targets) => targets.map((target) => ({ type: "add", target, options: {} }))))).pipe(Effect.map((items) => items.flat()));
+  const configured = entries.filter((entry) => entry.type === "document").flatMap((entry) => (entry.info.plugins ?? []).map(parse).map((operation) => {
+    if (operation.type === "remove")
+      return operation;
+    const directory = entry.path ? path.dirname(entry.path) : location.directory;
+    const target = operation.target.startsWith("file://") ? fileURLToPath(operation.target) : operation.target.startsWith("./") || operation.target.startsWith("../") ? path.resolve(directory, operation.target) : operation.target;
+    return { ...operation, target };
+  }));
+  const resolved = yield* Effect.forEach(configured, (operation) => Effect.gen(function* () {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return Option.some(operation);
+    if (yield* fs.isFile(operation.target)) {
+      yield* Effect.logWarning("configured plugin path must be a directory", { target: operation.target });
+      return Option.none();
+    }
+    return Option.some(operation);
+  })).pipe(Effect.map((operations) => operations.flatMap(Option.toArray)));
+  return yield* Effect.forEach([...discovered, ...resolved], (operation) => Effect.gen(function* () {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return [operation];
+    if (!(yield* fs.existsSafe(operation.target)))
+      return [operation];
+    const directory = yield* fs.isDir(operation.target);
+    const entrypoints = directory ? yield* Effect.sync(() => Host.resolve({ directory: operation.target })) : { server: pathToFileURL(operation.target).href };
+    if (!entrypoints.server)
+      return [];
+    if (directory) {
+      const root = yield* fs.resolve(operation.target);
+      const server = yield* fs.resolve(fileURLToPath(entrypoints.server));
+      if (!FSUtil.contains(root, server))
+        return [];
+    }
+    const times = yield* Effect.forEach([
+      ...Object.values(entrypoints).filter((entry) => entry !== undefined).map((entry) => fileURLToPath(entry)),
+      path.join(directory ? operation.target : path.dirname(operation.target), "package.json")
+    ], (entry) => fs.stat(entry).pipe(Effect.map((info) => Option.getOrElse(info.mtime, () => new Date(0)).getTime()), Effect.orElseSucceed(() => 0)));
+    return [{ ...operation, mtime: Math.max(...times) }];
+  })).pipe(Effect.map((operations) => operations.flat()));
+});
+function isPluginSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && names2.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)));
+}
+
+export { Service2, layer4, node4, empty2, exports_source };

package/dist/chunks/repository-shg3amz7.js

@@ -0,0 +1,190 @@
+import {
+  lazy2
+} from "./repository-88xbtdfr.js";
+import {
+  load2
+} from "./repository-paphc93g.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/filesystem/watcher.ts
+var exports_watcher = {};
+__export(exports_watcher, {
+  Event: () => Event10,
+  Native: () => Native3,
+  Options: () => Options9,
+  Service: () => Service45,
+  Test: () => Test3,
+  Watcher: () => exports_watcher,
+  configured: () => configured9,
+  hasNativeBinding: () => hasNativeBinding2,
+  layer: () => layer19,
+  nativeLayer: () => nativeLayer2,
+  nativeNode: () => nativeNode2,
+  node: () => node50,
+  testLayer: () => testLayer3
+});
+import { createWrapper } from "@parcel/watcher/wrapper";
+import { FileSystem } from "@opencode/schema/filesystem";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "effect";
+import { watch } from "node:fs";
+import path from "path";
+var SUBSCRIBE_TIMEOUT_MS = 1e4;
+var Event10 = { Updated: FileSystem.Event.Changed };
+var watcher = lazy2(() => {
+  try {
+    return createWrapper(load2());
+  } catch {
+    return;
+  }
+});
+function getBackend() {
+  if (process.platform === "win32")
+    return "windows";
+  if (process.platform === "darwin")
+    return "fs-events";
+  if (process.platform === "linux")
+    return "inotify";
+}
+var hasNativeBinding2 = () => !!watcher();
+
+class Native3 extends Context.Service()("@opencode/Watcher/Native") {
+}
+var Options9 = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean)
+});
+
+class Service45 extends Context.Service()("@opencode/Watcher") {
+}
+
+class Test3 extends Context.Service()("@opencode/Watcher/Test") {
+}
+var layer19 = (options) => Layer.effect(Service45, Effect.gen(function* () {
+  if (options?.enabled === false) {
+    return Service45.of({ subscribe: () => Effect.succeed(Stream.empty) });
+  }
+  const native = yield* Native3;
+  const watchers = yield* RcMap.make({
+    lookup: (key) => Effect.gen(function* () {
+      const pubsub = yield* Effect.acquireRelease(PubSub.unbounded(), (pubsub) => PubSub.shutdown(pubsub));
+      const subscription = yield* Effect.acquireRelease(native.subscribe({
+        ...key,
+        publish: (update) => PubSub.publishUnsafe(pubsub, update)
+      }), (subscription) => subscription ? Effect.promise(() => subscription.unsubscribe()).pipe(Effect.ignoreCause, Effect.andThen(Effect.logInfo("watcher stopped", { path: key.target, type: key.type }))) : Effect.void, { interruptible: true });
+      if (!subscription) {
+        yield* PubSub.shutdown(pubsub);
+        return pubsub;
+      }
+      yield* Effect.logInfo("watcher started", {
+        path: key.target,
+        type: key.type,
+        backend: subscription.backend,
+        ignores: key.ignore.length
+      });
+      return pubsub;
+    })
+  });
+  const subscribe = Effect.fnUntraced(function* (input, onReady = Effect.void) {
+    const target = path.resolve(input.path);
+    const ignore = [...new Set(input.type === "directory" ? input.ignore ?? [] : [])].toSorted();
+    const names = [...new Set(input.type === "entries" ? input.names : [])].toSorted();
+    yield* Effect.logInfo("watcher subscribe", {
+      path: target,
+      type: input.type,
+      ignores: ignore.length
+    });
+    return Stream.unwrap(Effect.gen(function* () {
+      const pubsub = yield* RcMap.get(watchers, { type: input.type, target, ignore, names });
+      const subscription = yield* PubSub.subscribe(pubsub);
+      if (yield* PubSub.isShutdown(pubsub))
+        return Stream.empty;
+      yield* onReady;
+      return Stream.fromSubscription(subscription);
+    }));
+  });
+  return Service45.of({ subscribe });
+}));
+var testLayer3 = Layer.effectContext(Effect.gen(function* () {
+  const subscriptions = [];
+  const active = new Map;
+  const native = Native3.of({
+    subscribe: (input) => Effect.sync(() => {
+      subscriptions.push(input.type === "file" ? { path: input.target, type: "file" } : input.type === "entries" ? { path: input.target, type: "entries", names: input.names } : input.ignore.length > 0 ? { path: input.target, type: "directory", ignore: input.ignore } : { path: input.target, type: "directory" });
+      const ignored = input.ignore.map((entry) => path.resolve(input.target, entry));
+      active.set(input.publish, (target) => {
+        if (input.type === "file")
+          return target === input.target;
+        if (input.type === "entries")
+          return path.dirname(target) === input.target && input.names.includes(path.basename(target));
+        return FSUtil.contains(input.target, target) && !ignored.some((entry) => FSUtil.contains(entry, target));
+      });
+      return {
+        unsubscribe: () => {
+          active.delete(input.publish);
+          return Promise.resolve();
+        }
+      };
+    })
+  });
+  const context = yield* Layer.build(layer19().pipe(Layer.provide(Layer.succeed(Native3, native))));
+  const test = Test3.of({
+    subscribe: Context.get(context, Service45).subscribe,
+    emit: (update) => Effect.sync(() => {
+      const target = path.resolve(update.path);
+      active.forEach((matches, publish) => {
+        if (matches(target))
+          publish(update);
+      });
+    }),
+    subscriptions: () => Effect.sync(() => [...subscriptions])
+  });
+  return Context.empty().pipe(Context.add(Service45, test), Context.add(Test3, test));
+}));
+var nativeLayer2 = Layer.succeed(Native3, Native3.of({
+  subscribe: (input) => {
+    if (input.type === "file" || input.type === "entries") {
+      return Effect.sync(() => {
+        const directory = input.type === "file" ? path.dirname(input.target) : input.target;
+        const names = new Set(input.type === "file" ? [path.basename(input.target)] : input.names);
+        const subscription = watch(directory, { recursive: false }, (_event, file) => {
+          if (file && !names.has(file))
+            return;
+          for (const name of file ? [file] : names) {
+            input.publish({ path: path.join(directory, name), type: "update" });
+          }
+        });
+        subscription.on("error", (error) => Effect.runFork(Effect.logError("watcher callback failed", { path: directory, error })));
+        return { unsubscribe: () => Promise.resolve(subscription.close()), backend: "node" };
+      });
+    }
+    return subscribeDirectory(watcher(), getBackend(), input.target, input.ignore, input.publish);
+  }
+}));
+var nativeNode2 = makeGlobalNode({ service: Native3, layer: nativeLayer2, deps: [] });
+function configured9(options) {
+  return makeGlobalNode({ service: Service45, layer: layer19(options), deps: [nativeNode2] });
+}
+var node50 = configured9();
+function subscribeDirectory(native, backend, directory, ignore, publish) {
+  if (!native || !backend) {
+    return Effect.logError("watcher backend not supported", { directory, platform: process.platform }).pipe(Effect.as(undefined));
+  }
+  const callback = (error, updates) => {
+    if (error)
+      Effect.runFork(Effect.logError("watcher callback failed", { error }));
+    for (const update of updates)
+      publish(update);
+  };
+  const pending = native.subscribe(directory, callback, { ignore: [...ignore], backend });
+  return Effect.promise(() => pending).pipe(Effect.map((subscription) => ({ unsubscribe: () => subscription.unsubscribe(), backend })), Effect.onInterrupt(() => Effect.sync(() => {
+    pending.then((subscription) => subscription.unsubscribe()).catch(() => {});
+  })), Effect.timeout(SUBSCRIBE_TIMEOUT_MS), Effect.catchCause((cause) => Effect.logError("failed to subscribe", {
+    directory,
+    cause: Cause.pretty(cause)
+  }).pipe(Effect.as(undefined))));
+}
+
+export { Event10, hasNativeBinding2, Native3, Options9, Service45, Test3, layer19, testLayer3, nativeLayer2, nativeNode2, configured9, node50, exports_watcher };

package/dist/chunks/repository-sj51pd9c.js

@@ -0,0 +1,22 @@
+import {
+  Plugin34
+} from "./repository-4e540xxx.js";
+import {
+  Plugin33
+} from "./repository-y1b098n8.js";
+import {
+  Plugin31
+} from "./repository-ff9w6xrb.js";
+import {
+  Plugin32
+} from "./repository-5y5h33xd.js";
+
+// src/plugin/websearch/index.ts
+var WebSearchPlugins2 = [
+  Plugin34,
+  Plugin33,
+  Plugin31,
+  Plugin32
+];
+
+export { WebSearchPlugins2 };