@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-j5346eb1.js

@@ -0,0 +1,608 @@
+import {
+  Metadata2,
+  node44
+} from "./repository-j4z2qnee.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  ID9,
+  Service61,
+  node65
+} from "./repository-b5n11jz6.js";
+import {
+  ID16
+} from "./repository-pye8sh6e.js";
+import {
+  Service72,
+  node76
+} from "./repository-c9wtqnwj.js";
+import {
+  ID14
+} from "./repository-nxamnhdf.js";
+import {
+  ID15,
+  OAuth3
+} from "./repository-sztg2hv4.js";
+import {
+  ID13,
+  MethodID2,
+  AttemptID2,
+  Method2,
+  Service74,
+  node78
+} from "./repository-0zkv00cg.js";
+import {
+  Service73,
+  node77
+} from "./repository-gtm8txn9.js";
+import {
+  Service69,
+  node73
+} from "./repository-3tamc9js.js";
+import {
+  Service63,
+  node67
+} from "./repository-ksjan0t5.js";
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  Info24,
+  Ref2,
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Service53,
+  node57
+} from "./repository-2yv9jfkc.js";
+import {
+  ID17
+} from "./repository-36564s8r.js";
+import {
+  Service31,
+  node36
+} from "./repository-3yetcf2r.js";
+import {
+  Service62,
+  node66
+} from "./repository-mgx963cj.js";
+import {
+  Service58,
+  node62
+} from "./repository-ykpr0q7c.js";
+import {
+  Service41,
+  node46
+} from "./repository-39fveamk.js";
+import {
+  Source4,
+  Service55,
+  node59
+} from "./repository-z0xnky3q.js";
+import {
+  Info7,
+  Service40,
+  node45
+} from "./repository-9xb0s4b9.js";
+import {
+  Service26,
+  node30
+} from "./repository-51cmmk6m.js";
+import {
+  Service16,
+  node20
+} from "./repository-v3v5frkk.js";
+import {
+  Service15,
+  node19
+} from "./repository-2v08kgv1.js";
+import {
+  Service17,
+  node21
+} from "./repository-xp6wb0v9.js";
+import {
+  ID4,
+  Service21,
+  node25
+} from "./repository-0k7wafs3.js";
+import {
+  StrategyID2,
+  Info4,
+  ListEntry3,
+  UnsupportedLocationError2,
+  Service18,
+  node22
+} from "./repository-cedwm630.js";
+import {
+  Service70,
+  node74
+} from "./repository-4emgtgzt.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/host.ts
+var exports_host = {};
+__export(exports_host, {
+  PluginHost: () => exports_host,
+  make: () => make11,
+  requirements: () => requirements3,
+  storage: () => storage2
+});
+import { EventManifest } from "@opencode/schema/event-manifest";
+import { ServerConfig } from "@opencode/schema/mcp";
+import { Effect, Schema, Stream } from "effect";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+var mutable = (value) => value;
+var isRpcEvent = (event) => event.type.startsWith("rpc.");
+var make11 = Effect.fn("PluginHost.make")(function* (plugin, pluginID = "test") {
+  const app = yield* Metadata2;
+  const agents = yield* Service61;
+  const aisdk = yield* Service72;
+  const catalog = yield* Service73;
+  const commands = yield* Service69;
+  const bus = yield* Service78;
+  const integration = yield* Service74;
+  const kv = yield* Service63;
+  const mcp = yield* Service31;
+  const location = yield* Service66;
+  const reference = yield* Service55;
+  const rpc = yield* Service15;
+  const skill = yield* Service40;
+  const tools = yield* Service41;
+  const vcs = yield* Service17;
+  const websearch = yield* Service21;
+  const generate = yield* Service70;
+  const permission = yield* Service58;
+  const hooks = yield* Service62;
+  const sessions = yield* Service26;
+  const persistentPty = yield* Service16;
+  const locations = yield* Service53;
+  const worktrees = yield* Service18;
+  const locationInfo = () => new Info24({
+    directory: location.directory,
+    workspaceID: location.workspaceID,
+    project: location.project
+  });
+  const locationRef = (input) => input?.location === undefined ? undefined : Ref2.make({
+    directory: AbsolutePath2.make(input.location.directory ?? location.directory),
+    workspaceID: input.location.workspace === undefined ? location.workspaceID : ID17.make(input.location.workspace)
+  });
+  const isCurrentLocation = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
+  const response = (effect) => effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })));
+  const atWorktree = (ref, run) => {
+    if (ref?.workspaceID)
+      return Effect.fail(new UnsupportedLocationError2({ directory: ref.directory }));
+    if (!ref || isCurrentLocation(ref))
+      return run(worktrees);
+    return Effect.gen(function* () {
+      const { Plugin } = yield* Effect.promise(() => import("../plugin.js"));
+      const plugins = yield* Plugin.Service;
+      const target = yield* Service18;
+      yield* plugins.awaitActivation;
+      return yield* run(target);
+    }).pipe(Effect.provide(locations.get(ref)));
+  };
+  const decodeWorktree = Schema.decodeUnknownEffect(Info4);
+  const decodeWorktrees = Schema.decodeUnknownEffect(Schema.Array(ListEntry3));
+  const listAgents = Effect.fn("PluginHost.listAgents")((ref) => Effect.gen(function* () {
+    const location = yield* Service66;
+    const agents = yield* Service61;
+    return {
+      location: new Info24({
+        directory: location.directory,
+        workspaceID: location.workspaceID,
+        project: location.project
+      }),
+      data: yield* agents.list()
+    };
+  }).pipe(Effect.provide(locations.get(ref)), Effect.orDie));
+  const context = {
+    app,
+    location: locationInfo(),
+    options: {},
+    rpc: Object.assign(rpc.client, { register: rpc.register }),
+    agent: {
+      get: (input) => {
+        const ref = locationRef(input);
+        const output = ref && !isCurrentLocation(ref) ? listAgents(ref).pipe(Effect.map((result) => ({
+          ...result,
+          data: result.data.find((agent) => agent.id === input.agentID)
+        }))) : response(agents.get(input.agentID));
+        return output.pipe(Effect.flatMap((result) => result.data ? Effect.succeed({ ...result, data: result.data }) : Effect.fail(new Error(`Agent not found: ${input.agentID}`))));
+      },
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return listAgents(ref);
+        return response(agents.list());
+      },
+      reload: agents.reload,
+      transform: (callback) => agents.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(ID9.make(id))),
+          default: (id) => editor.default(id === undefined ? undefined : ID9.make(id)),
+          update: (id, update) => editor.update(ID9.make(id), update),
+          remove: (id) => editor.remove(ID9.make(id))
+        });
+      })
+    },
+    aisdk: {
+      hook: (name, callback, options) => {
+        if (name === "sdk") {
+          return aisdk.hook.sdk((event) => {
+            if (options?.providerID !== undefined && options.providerID !== event.model.providerID)
+              return Effect.void;
+            const output = {
+              model: mutable(event.model),
+              package: event.package,
+              options: event.options,
+              sdk: event.sdk
+            };
+            return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.sdk = output.sdk)));
+          });
+        }
+        return aisdk.hook.language((event) => {
+          if (options?.providerID !== undefined && options.providerID !== event.model.providerID)
+            return Effect.void;
+          const output = {
+            model: mutable(event.model),
+            options: event.options,
+            sdk: event.sdk,
+            language: event.language
+          };
+          return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.language = output.language)));
+        });
+      }
+    },
+    catalog: {
+      provider: {
+        list: () => response(catalog.provider.available()),
+        get: (input) => catalog.provider.get(ID16.make(input.providerID)).pipe(Effect.flatMap((provider) => provider === undefined ? Effect.fail(new Error(`Provider not found: ${input.providerID}`)) : response(Effect.succeed(provider))))
+      },
+      model: {
+        list: () => response(catalog.model.available()),
+        default: () => response(catalog.model.default())
+      },
+      reload: catalog.reload,
+      transform: (callback) => catalog.transform((editor) => {
+        callback({
+          provider: {
+            list: () => mutable(editor.provider.list()),
+            get: (id) => mutable(editor.provider.get(ID16.make(id))),
+            update: (id, update) => editor.provider.update(ID16.make(id), update),
+            remove: (id) => editor.provider.remove(ID16.make(id))
+          },
+          model: {
+            get: (providerID, modelID) => mutable(editor.model.get(ID16.make(providerID), ID14.make(modelID))),
+            update: (providerID, modelID, update) => editor.model.update(ID16.make(providerID), ID14.make(modelID), update),
+            remove: (providerID, modelID) => editor.model.remove(ID16.make(providerID), ID14.make(modelID)),
+            default: {
+              get: editor.model.default.get,
+              set: (providerID, modelID) => editor.model.default.set(ID16.make(providerID), ID14.make(modelID))
+            }
+          }
+        });
+      })
+    },
+    command: {
+      list: () => response(commands.list()),
+      reload: commands.reload,
+      transform: commands.transform
+    },
+    event: {
+      subscribe: () => bus.subscribe().pipe(Stream.filter((event) => EventManifest.isServer(event) || isRpcEvent(event)))
+    },
+    experimental: {
+      terminal: {
+        read: (input) => persistentPty.read(input.sessionID, input.lines)
+      }
+    },
+    generate: {
+      text: (input) => generate.text(input).pipe(Effect.map((text) => ({ text })))
+    },
+    integration: {
+      list: () => response(integration.list()),
+      get: (input) => response(integration.get(ID13.make(input.integrationID))),
+      connect: {
+        key: (input) => integration.connection.key({
+          integrationID: ID13.make(input.integrationID),
+          key: input.key,
+          answer: input.answer,
+          label: input.label
+        })
+      },
+      oauth: {
+        connect: (input) => response(integration.oauth.connect({
+          integrationID: ID13.make(input.integrationID),
+          methodID: MethodID2.make(input.methodID),
+          answer: input.answer,
+          label: input.label
+        })),
+        status: (input) => response(integration.oauth.status({
+          integrationID: ID13.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })),
+        complete: (input) => integration.oauth.complete({
+          integrationID: ID13.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID),
+          code: input.code
+        }),
+        cancel: (input) => integration.oauth.cancel({
+          integrationID: ID13.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })
+      },
+      command: {
+        connect: (input) => response(integration.command.connect({
+          integrationID: ID13.make(input.integrationID),
+          methodID: MethodID2.make(input.methodID),
+          label: input.label
+        })),
+        status: (input) => response(integration.command.status({
+          integrationID: ID13.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })),
+        cancel: (input) => integration.command.cancel({
+          integrationID: ID13.make(input.integrationID),
+          attemptID: AttemptID2.make(input.attemptID)
+        })
+      },
+      reload: integration.reload,
+      connection: {
+        active: (id) => integration.connection.active(ID13.make(id)),
+        resolve: (connection) => integration.connection.resolve(connection.type === "credential" ? { ...connection, id: ID15.make(connection.id) } : connection)
+      },
+      transform: (callback) => integration.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: (id) => mutable(editor.get(ID13.make(id))),
+          update: (id, update) => editor.update(ID13.make(id), update),
+          remove: (id) => editor.remove(ID13.make(id)),
+          method: {
+            list: (id) => editor.method.list(ID13.make(id)),
+            update: (input) => editor.method.update(methodImplementation(input)),
+            remove: (id, method) => editor.method.remove(ID13.make(id), Schema.decodeUnknownSync(Method2)(method))
+          }
+        });
+      })
+    },
+    mcp: {
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return Effect.gen(function* () {
+            const location = yield* Service66;
+            const mcp = yield* Service31;
+            return {
+              location: new Info24({
+                directory: location.directory,
+                workspaceID: location.workspaceID,
+                project: location.project
+              }),
+              data: yield* mcp.servers()
+            };
+          }).pipe(Effect.provide(locations.get(ref)));
+        return response(mcp.servers());
+      },
+      reload: mcp.reload,
+      transform: (callback) => mcp.transform((editor) => {
+        callback({
+          list: () => editor.list().map(([name, config]) => [name, mutable(config)]),
+          get: (name) => mutable(editor.get(name)),
+          set: (name, config) => editor.set(name, Schema.decodeUnknownSync(ServerConfig)(config)),
+          update: editor.update,
+          remove: editor.remove
+        });
+      })
+    },
+    permission: {
+      hook: (name, callback) => hooks.register("permission", name, callback),
+      list: (input) => permission.forSession(input.sessionID),
+      get: (input) => permission.get(input.requestID).pipe(Effect.flatMap((request) => request?.sessionID === input.sessionID ? Effect.succeed(request) : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)))),
+      reply: (input) => permission.get(input.requestID).pipe(Effect.flatMap((request) => request?.sessionID === input.sessionID ? permission.reply({ requestID: input.requestID, reply: input.reply, message: input.message }) : Effect.fail(new Error(`Permission request not found: ${input.requestID}`)))),
+      rules: sessions.setPermissions
+    },
+    plugin: {
+      list: () => response(plugin.list())
+    },
+    reference: {
+      list: () => response(reference.list()),
+      reload: reference.reload,
+      transform: (callback) => reference.transform((editor) => {
+        callback({
+          add: (name, source) => editor.add(name, Schema.decodeUnknownSync(Source4)(source)),
+          remove: editor.remove,
+          list: editor.list,
+          get: editor.get
+        });
+      })
+    },
+    skill: {
+      list: () => response(skill.list()),
+      reload: skill.reload,
+      transform: (callback) => skill.transform((editor) => {
+        callback({
+          list: () => mutable(editor.list()),
+          get: editor.get,
+          add: (value) => editor.add(Schema.decodeUnknownSync(Info7)(value)),
+          update: editor.update,
+          remove: editor.remove
+        });
+      })
+    },
+    storage: storage2(kv, pluginID),
+    shell: {
+      hook: (name, callback) => hooks.register("shell", name, callback)
+    },
+    tool: {
+      transform: tools.transform,
+      reload: tools.reload,
+      hook: (name, callback) => hooks.register("tool", name, callback)
+    },
+    vcs: {
+      get: () => response(vcs.info()),
+      base: () => response(vcs.base()),
+      branches: (input) => response(vcs.branches({ search: input?.search, limit: input?.limit })),
+      status: () => response(vcs.status()),
+      diff: (input) => response(vcs.diff(input.mode, { context: input.context, base: input.base })),
+      transform: vcs.transform,
+      reload: vcs.reload
+    },
+    websearch: {
+      providers: () => response(websearch.providers()),
+      query: (input) => response(websearch.query({
+        query: input.query,
+        providerID: input.providerID === undefined ? undefined : ID4.make(input.providerID)
+      })),
+      reload: websearch.reload,
+      transform: (callback) => websearch.transform((editor) => {
+        callback({
+          add: (definition) => editor.add({
+            id: ID4.make(definition.id),
+            name: definition.name,
+            execute: definition.execute
+          }),
+          default: {
+            get: editor.default.get,
+            set: (selection) => editor.default.set(selection === false || selection === "random" ? selection : ID4.make(selection))
+          }
+        });
+      })
+    },
+    worktree: {
+      list: (input) => atWorktree(locationRef(input), (service) => service.list()),
+      create: (input) => atWorktree(locationRef(input), (service) => service.create(input)),
+      refresh: (input) => atWorktree(locationRef(input), (service) => service.refresh()).pipe(Effect.asVoid),
+      remove: (input) => atWorktree(locationRef(input), (service) => service.remove(input)),
+      reload: worktrees.reload,
+      transform: (callback) => worktrees.transform((editor) => callback({
+        add: (definition) => editor.add({
+          id: StrategyID2.make(definition.id),
+          create: (input) => definition.create(input).pipe(Effect.flatMap(decodeWorktree)),
+          remove: (input) => definition.remove(input),
+          list: (directory) => definition.list(directory).pipe(Effect.flatMap(decodeWorktrees))
+        })
+      }))
+    },
+    session: {
+      hook: (name, callback, options) => hooks.register("session", name, callback, options),
+      create: (input) => sessions.create({
+        id: input?.id,
+        title: input?.title,
+        agent: input?.agent,
+        model: input?.model,
+        metadata: input?.metadata,
+        permissions: input?.permissions,
+        location: input?.location ?? Ref2.make({ directory: location.directory, workspaceID: location.workspaceID })
+      }),
+      get: (input) => sessions.get(input.sessionID),
+      switchAgent: sessions.switchAgent,
+      switchModel: sessions.switchModel,
+      prompt: sessions.prompt,
+      generate: (input) => sessions.generate(input).pipe(Effect.map((text) => ({ text }))),
+      command: sessions.command,
+      rename: sessions.rename,
+      move: sessions.move,
+      synthetic: sessions.synthetic,
+      interrupt: (input) => sessions.interrupt(input.sessionID, { continue: input.continue }).pipe(Effect.map((interrupted) => ({ interrupted }))),
+      wait: (input) => sessions.wait(input.sessionID),
+      context: (input) => sessions.context(input.sessionID)
+    }
+  };
+  return context;
+});
+var requirements3 = LayerNode.group([
+  node44,
+  node65,
+  node76,
+  node77,
+  node73,
+  node83,
+  node78,
+  node67,
+  node36,
+  node70,
+  node59,
+  node19,
+  node45,
+  node46,
+  node21,
+  node25,
+  node22,
+  node74,
+  node62,
+  node66,
+  node30,
+  node20,
+  node57
+]);
+function storage2(kv, pluginID) {
+  const namespace = `plugin:${pluginID.split("").map((value) => value.charCodeAt(0).toString(16).padStart(4, "0")).join("")}:`;
+  return {
+    get: (key) => kv.get(namespace + key),
+    set: (key, value) => kv.set(namespace + key, value),
+    remove: (key) => kv.remove(namespace + key),
+    scan: (options) => kv.scan({
+      prefix: namespace + options.prefix,
+      after: options.after === undefined ? undefined : namespace + options.after,
+      limit: options.limit
+    }).pipe(Effect.map((result) => {
+      const entries = result.entries.map((entry) => ({
+        key: entry.key.slice(namespace.length),
+        value: entry.value
+      }));
+      if (result.next === undefined)
+        return { entries };
+      return { entries, next: result.next.slice(namespace.length) };
+    }))
+  };
+}
+function methodImplementation(input) {
+  if ("authorize" in input) {
+    const refresh = input.refresh;
+    return {
+      integrationID: ID13.make(input.integrationID),
+      method: { ...input.method, id: MethodID2.make(input.method.id) },
+      authorize: (answer) => input.authorize(answer).pipe(Effect.map((authorization) => {
+        if (authorization.mode === "auto") {
+          return {
+            ...authorization,
+            callback: authorization.callback.pipe(Effect.map(credential))
+          };
+        }
+        return {
+          ...authorization,
+          callback: (code) => authorization.callback(code).pipe(Effect.map(credential))
+        };
+      })),
+      ...refresh ? { refresh: (value) => refresh(value).pipe(Effect.map(credential)) } : {},
+      ...input.label ? { label: input.label } : {}
+    };
+  }
+  if (input.method.type === "env") {
+    return {
+      integrationID: ID13.make(input.integrationID),
+      method: input.method
+    };
+  }
+  if (input.method.type === "command") {
+    return {
+      integrationID: ID13.make(input.integrationID),
+      method: { ...input.method, id: MethodID2.make(input.method.id) }
+    };
+  }
+  return {
+    integrationID: ID13.make(input.integrationID),
+    method: input.method
+  };
+}
+function credential(value) {
+  return OAuth3.make({ ...value, methodID: MethodID2.make(value.methodID) });
+}
+
+export { make11, requirements3, storage2, exports_host };

package/dist/chunks/repository-j56e64zr.js

@@ -0,0 +1,40 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config/watch.ts
+var exports_watch = {};
+__export(exports_watch, {
+  ConfigWatch: () => exports_watch,
+  plan: () => plan2
+});
+import path from "path";
+import { FSUtil } from "@opencode/util/fs-util";
+function plan2(sources) {
+  const directories = [
+    ...sources.global ? [sources.global] : [],
+    ...sources.project.filter((root) => root.present).map((root) => root.path)
+  ];
+  const files = [
+    ...sources.direct,
+    ...sources.project.map((root) => root.path),
+    ...sources.claude,
+    ...sources.agents,
+    ...sources.explicit ? [sources.explicit] : []
+  ];
+  const parents = Map.groupBy(files.filter((file) => !directories.some((directory) => file !== directory && FSUtil.contains(directory, file))), (file) => path.dirname(file));
+  return new Map([
+    ...directories.map((path2) => ({
+      path: path2,
+      type: "directory",
+      ignore: ["node_modules", ".git", "**/{node_modules,.git}/**"]
+    })),
+    ...Array.from(parents, ([parent, files]) => ({
+      path: parent,
+      type: "entries",
+      names: [...new Set(files.map((file) => path.basename(file)))].toSorted()
+    }))
+  ].map((target) => [JSON.stringify(target), target]));
+}
+
+export { plan2, exports_watch };