@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-padshwcv.js

@@ -0,0 +1,103 @@
+import {
+  CredentialTable
+} from "./ripgrep-mf0hyk7z.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/credential.ts
+var exports_credential = {};
+__export(exports_credential, {
+  node: () => node,
+  Value: () => Value,
+  Service: () => Service,
+  OAuth: () => OAuth,
+  Key: () => Key,
+  Info: () => Info,
+  ID: () => ID,
+  Credential: () => exports_credential
+});
+import { asc, eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Integration } from "@opencode-ai/schema/integration";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var ID = Credential.ID;
+var OAuth = Credential.OAuth;
+var Key = Credential.Key;
+var Value = Credential.Value;
+
+class Info extends Schema.Class("Credential.Info")({
+  id: ID,
+  integrationID: Integration.ID,
+  label: Schema.String,
+  value: Value
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Credential") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const decode = Schema.decodeUnknownSync(Value);
+  const stored = (row) => {
+    if (!row.integration_id)
+      return;
+    return new Info({
+      id: row.id,
+      integrationID: row.integration_id,
+      label: row.label,
+      value: decode(row.value)
+    });
+  };
+  return Service.of({
+    all: Effect.fn("Credential.all")(function* () {
+      return (yield* db.select().from(CredentialTable).orderBy(asc(CredentialTable.time_created)).all().pipe(Effect.orDie)).flatMap((row) => {
+        const credential = stored(row);
+        return credential ? [credential] : [];
+      });
+    }),
+    list: Effect.fn("Credential.list")(function* (integrationID) {
+      return (yield* db.select().from(CredentialTable).where(eq(CredentialTable.integration_id, integrationID)).orderBy(asc(CredentialTable.time_created)).all().pipe(Effect.orDie)).flatMap((row) => {
+        const credential = stored(row);
+        return credential ? [credential] : [];
+      });
+    }),
+    get: Effect.fn("Credential.get")(function* (id) {
+      const row = yield* db.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
+      return row ? stored(row) : undefined;
+    }),
+    create: Effect.fn("Credential.create")(function* (input) {
+      const credential = new Info({
+        id: ID.create(),
+        integrationID: input.integrationID,
+        label: input.label ?? "default",
+        value: input.value
+      });
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        yield* tx.delete(CredentialTable).where(eq(CredentialTable.integration_id, credential.integrationID)).run();
+        yield* tx.insert(CredentialTable).values({
+          id: credential.id,
+          integration_id: credential.integrationID,
+          label: credential.label,
+          value: credential.value
+        }).run();
+      })).pipe(Effect.orDie);
+      return credential;
+    }),
+    update: Effect.fn("Credential.update")(function* (id, updates) {
+      if (!updates.label && !updates.value)
+        return;
+      yield* db.update(CredentialTable).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
+    }),
+    remove: Effect.fn("Credential.remove")(function* (id) {
+      yield* db.delete(CredentialTable).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { ID, OAuth, Key, Value, Info, Service, node, exports_credential };

package/dist/chunks/ripgrep-pfqehjmy.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./ripgrep-0zz82cjq.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/deepinfra.ts
+var DeepInfraPlugin = createProviderPlugin({
+  id: "opencode.provider.deepinfra",
+  package: "@ai-sdk/deepinfra",
+  load: async (options) => {
+    const { createDeepInfra } = await import("@ai-sdk/deepinfra");
+    return createDeepInfra(options);
+  }
+});
+
+export { DeepInfraPlugin };

package/dist/chunks/ripgrep-ph1me6ah.js

@@ -0,0 +1,156 @@
+import {
+  MAX_PATCH_BYTES,
+  MAX_TOTAL_PATCH_BYTES,
+  PATCH_CONTEXT_LINES,
+  addPatch,
+  chunksByFile,
+  countPatch,
+  deletePatch,
+  emptyPatch
+} from "./ripgrep-vz89hfgr.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/vcs/hg.ts
+var exports_hg = {};
+__export(exports_hg, {
+  make: () => make,
+  VcsHg: () => exports_hg
+});
+import path from "path";
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+function make(proc, fs, input) {
+  const hg = makeHg(proc, input.worktree);
+  const scope = path.relative(input.worktree, input.directory) || ".";
+  const patchFor = Effect.fnUntraced(function* (item, rev, chunk) {
+    if (chunk !== undefined)
+      return chunk;
+    if (item.code === "?") {
+      const content = yield* fs.readFileString(path.join(input.worktree, item.file)).pipe(Effect.catch(() => Effect.succeed(undefined)));
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES)
+        return emptyPatch(item.file);
+      return addPatch(item.file, content);
+    }
+    if (item.code === "!") {
+      const content = yield* hg.cat(rev ?? ".", item.file);
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES)
+        return emptyPatch(item.file);
+      return deletePatch(item.file, content);
+    }
+    return emptyPatch(item.file);
+  });
+  const diffAgainst = Effect.fnUntraced(function* (rev, options) {
+    const [items, batch] = yield* Effect.all([hg.status(rev, scope), hg.diff(rev, scope, { context: options?.context ?? PATCH_CONTEXT_LINES })], { concurrency: 2 });
+    const chunks = chunksByFile(batch, () => {
+      return;
+    });
+    const list = [];
+    for (const item of items.toSorted((a, b) => a.file.localeCompare(b.file))) {
+      const patch = yield* patchFor(item, rev, chunks.get(item.file));
+      const counts = countPatch(patch);
+      list.push({
+        file: item.file,
+        patch,
+        additions: counts.additions,
+        deletions: counts.deletions,
+        status: item.status
+      });
+    }
+    return list;
+  });
+  return {
+    info: Effect.fn("VcsHg.info")(function* () {
+      return { branch: { current: yield* hg.branch(), default: "default" } };
+    }),
+    status: Effect.fn("VcsHg.status")(function* () {
+      const [items, batch] = yield* Effect.all([hg.status(undefined, scope), hg.diff(undefined, scope, { context: 0 })], { concurrency: 2 });
+      const chunks = chunksByFile(batch, () => {
+        return;
+      });
+      return yield* Effect.forEach(items.toSorted((a, b) => a.file.localeCompare(b.file)), (item) => Effect.gen(function* () {
+        const patch = yield* patchFor(item, undefined, chunks.get(item.file));
+        const counts = countPatch(patch);
+        return {
+          file: item.file,
+          additions: counts.additions,
+          deletions: counts.deletions,
+          status: item.status
+        };
+      }));
+    }),
+    diff: Effect.fn("VcsHg.diff")(function* (mode, options) {
+      if (mode === "working")
+        return yield* diffAgainst(undefined, options);
+      const branch = yield* hg.branch();
+      if (!branch || branch === "default")
+        return [];
+      const ancestor = yield* hg.ancestor();
+      if (!ancestor)
+        return [];
+      return yield* diffAgainst(ancestor, options);
+    })
+  };
+}
+var kind = (code) => {
+  if (code === "A" || code === "?")
+    return "added";
+  if (code === "R" || code === "!")
+    return "deleted";
+  return "modified";
+};
+function makeHg(proc, worktree) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("hg", args, {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts?.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.catch(() => Effect.succeed({ exitCode: 1, text: () => "", truncated: false })));
+  const status = Effect.fn("VcsHg.statusNames")(function* (rev, scope) {
+    const result = yield* run(["status", "-0", ...rev ? ["--rev", rev] : [], scope]);
+    if (result.exitCode !== 0)
+      return [];
+    return result.text().split("\x00").filter(Boolean).flatMap((entry) => {
+      const code = entry.slice(0, 1);
+      const file = entry.slice(2);
+      if (!file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsHg.diffPatch")(function* (rev, scope, options) {
+    const result = yield* run(["diff", "--git", "--unified", String(options.context), ...rev ? ["-r", rev] : [], scope], { maxOutputBytes: MAX_TOTAL_PATCH_BYTES });
+    if (result.exitCode !== 0)
+      return { text: "", truncated: false };
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const branch = Effect.fn("VcsHg.branch")(function* () {
+    const result = yield* run(["branch"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fn("VcsHg.ancestor")(function* () {
+    const result = yield* run(["log", "-r", "ancestor(., default)", "-T", "{node}"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const cat = Effect.fn("VcsHg.cat")(function* (rev, file) {
+    const result = yield* run(["cat", "-r", rev, "--", file], { maxOutputBytes: MAX_PATCH_BYTES });
+    if (result.exitCode !== 0 || result.truncated)
+      return;
+    return result.text();
+  });
+  return { status, diff, branch, ancestor, cat };
+}
+
+export { make, exports_hg };

package/dist/chunks/ripgrep-pn1rs1sd.js

@@ -0,0 +1,147 @@
+import {
+  exports_config
+} from "./ripgrep-rz9mfttk.js";
+import {
+  exports_watcher
+} from "./ripgrep-y980s7ka.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/config/plugin/source.ts
+var exports_source = {};
+__export(exports_source, {
+  node: () => node,
+  layer: () => layer,
+  empty: () => empty,
+  Service: () => Service,
+  ConfigPluginSource: () => exports_source
+});
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Option, Predicate, PubSub, Schema, Stream } from "effect";
+import path from "path";
+import { fileURLToPath } from "url";
+class Service extends Context.Service()("@opencode/ConfigPluginSource") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const config = yield* exports_config.Service;
+  const watcher = yield* exports_watcher.Service;
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  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;
+      if (yield* fs.isDir(operation.target))
+        continue;
+      watched.add(operation.target);
+      const updates = yield* watcher.subscribe({ path: operation.target, type: "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 Service.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 node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_config.node, FSUtil.node, exports_watcher.node, exports_location.node]
+});
+var empty = makeLocationNode({
+  service: Service,
+  layer: Layer.succeed(Service, Service.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) => discoverDirectory(fs, entry.path)).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 };
+  }));
+  return yield* Effect.forEach([...discovered, ...configured], (operation) => {
+    if (operation.type === "remove" || !path.isAbsolute(operation.target))
+      return Effect.succeed(operation);
+    return fs.stat(operation.target).pipe(Effect.map((info) => ({
+      ...operation,
+      mtime: Option.getOrElse(info.mtime, () => new Date(0)).getTime()
+    })), Effect.catch(() => Effect.succeed(operation)));
+  });
+});
+var sourceDirectories = ["plugin", "plugins"];
+var Package = Schema.Struct({
+  exports: Schema.optional(Schema.Unknown),
+  module: Schema.optional(Schema.Unknown),
+  main: Schema.optional(Schema.Unknown)
+});
+var decodePackage = Schema.decodeUnknownOption(Package);
+function discoverDirectory(fs, directory) {
+  return Effect.gen(function* () {
+    const children = (yield* Effect.forEach(sourceDirectories, (source) => fs.readDirectoryEntries(path.join(directory, source)).pipe(Effect.orElseSucceed(() => []), Effect.map((entries) => entries.map((entry) => ({ ...entry, target: path.join(directory, source, entry.name) })))))).flat().sort((a, b) => a.target < b.target ? -1 : a.target > b.target ? 1 : 0);
+    const targets = yield* Effect.forEach(children, (entry) => discoverChild(fs, entry));
+    return targets.flatMap(Option.toArray).map((target) => ({ type: "add", target, options: {} }));
+  });
+}
+function discoverChild(fs, entry) {
+  return Effect.gen(function* () {
+    const source = entry.target.endsWith(".ts") || entry.target.endsWith(".js");
+    if (entry.type === "file" && source)
+      return Option.some(entry.target);
+    if (entry.type === "directory")
+      return yield* discoverPackage(fs, entry.target);
+    if (entry.type !== "symlink")
+      return Option.none();
+    if (source && (yield* fs.isFile(entry.target)))
+      return Option.some(entry.target);
+    if (yield* fs.isDir(entry.target))
+      return yield* discoverPackage(fs, entry.target);
+    return Option.none();
+  });
+}
+function discoverPackage(fs, directory) {
+  return Effect.gen(function* () {
+    const root = yield* fs.resolve(directory);
+    const manifest = yield* fs.readJson(path.join(directory, "package.json")).pipe(Effect.map(decodePackage), Effect.orElseSucceed(Option.none));
+    const configured = Option.isSome(manifest) ? [manifest.value.exports, manifest.value.module, manifest.value.main].filter(Predicate.isString) : [];
+    return yield* Effect.findFirst([...configured, "index.ts", "index.js"].filter((entry) => !path.isAbsolute(entry)).map((entry) => path.resolve(directory, entry)).filter((entry) => FSUtil.contains(directory, entry)), (entry) => fs.isFile(entry).pipe(Effect.flatMap((exists) => exists ? fs.resolve(entry).pipe(Effect.map((resolved) => FSUtil.contains(root, resolved))) : Effect.succeed(false))));
+  });
+}
+function isPluginSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)));
+}
+
+export { Service, layer, node, empty, exports_source };

package/dist/chunks/ripgrep-pq4b4pqk.js

@@ -0,0 +1,29 @@
+import {
+  PositiveInt
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/server.ts
+var exports_server = {};
+__export(exports_server, {
+  Server: () => Server,
+  ConfigServerV1: () => exports_server
+});
+import { Schema } from "effect";
+var Server = Schema.Struct({
+  port: Schema.optional(PositiveInt).annotate({
+    description: "Port to listen on"
+  }),
+  hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
+  mdns: Schema.optional(Schema.Boolean).annotate({ description: "Enable mDNS service discovery" }),
+  mdnsDomain: Schema.optional(Schema.String).annotate({
+    description: "Custom domain name for mDNS service (default: opencode.local)"
+  }),
+  cors: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Additional domains to allow for CORS"
+  })
+}).annotate({ identifier: "ServerConfig" });
+
+export { Server, exports_server };

package/dist/chunks/ripgrep-prf9bavk.js

@@ -0,0 +1,96 @@
+import {
+  exports_mcp
+} from "./ripgrep-1c00jchy.js";
+import {
+  exports_app
+} from "./ripgrep-50jxp3hw.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/websearch/parallel.ts
+var exports_parallel = {};
+__export(exports_parallel, {
+  endpoint: () => endpoint,
+  WebSearchParallel: () => exports_parallel,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint = "https://search.parallel.ai/mcp";
+var McpInput = Schema.Struct({
+  objective: Schema.String,
+  search_queries: Schema.Array(Schema.String),
+  model_name: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional)
+});
+var SearchResponse = Schema.Struct({
+  search_id: Schema.String,
+  results: Schema.Array(Schema.Struct({
+    url: Schema.String,
+    title: Schema.NullOr(Schema.String).pipe(Schema.optional),
+    publish_date: Schema.NullOr(Schema.String).pipe(Schema.optional),
+    excerpts: Schema.Array(Schema.String)
+  })),
+  warnings: Schema.NullOr(Schema.Array(Schema.Struct({
+    type: Schema.Literals(["spec_validation_warning", "input_validation_warning", "warning"]),
+    message: Schema.String,
+    detail: Schema.NullOr(Schema.Record(Schema.String, Schema.Json)).pipe(Schema.optional)
+  }))).pipe(Schema.optional),
+  usage: Schema.NullOr(Schema.Array(Schema.Struct({
+    name: Schema.String,
+    count: Schema.Int
+  }))).pipe(Schema.optional),
+  session_id: Schema.String
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
+  structuredContent: SearchResponse
+});
+var Plugin = define({
+  id: "opencode.websearch.parallel",
+  effect: Effect.fn("WebSearchParallel.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((draft) => {
+      draft.update("parallel", (integration) => integration.name = "Parallel");
+      draft.method.update({
+        integrationID: "parallel",
+        method: { type: "key" }
+      });
+      draft.method.update({
+        integrationID: "parallel",
+        method: { type: "env", names: ["PARALLEL_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "parallel",
+        name: "Parallel",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("parallel");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const result = yield* exports_mcp.call(http, endpoint, "web_search", { input: McpInput, output: McpOutput }, {
+            objective: input.query,
+            search_queries: [input.query]
+          }, {
+            "User-Agent": exports_app.useragent(ctx.app),
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
+          });
+          return result?.structuredContent.results.map((item) => {
+            const published = item.publish_date ? Date.parse(item.publish_date) : undefined;
+            return {
+              url: item.url,
+              ...item.title ? { title: item.title } : {},
+              ...item.excerpts.length ? { content: item.excerpts.join(`
+
+`) } : {},
+              time: { ...published !== undefined && Number.isFinite(published) ? { published } : {} }
+            };
+          }) ?? [];
+        })
+      });
+    });
+  })
+});
+
+export { endpoint, Plugin, exports_parallel };